tests: refactor code to use a single test url generator

rhodecode/api/__init__.py

@@ -1,574 +1,573 b''
 # 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: int | None = None, headers: dict | None = 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)
         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)
+        fault_message = f"No such method: {method}. Similar methods: {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 = f"{exc.__class__.__module__}.{exc.__class__.__name__}"
             statsd.incr('rhodecode_exception_total',
                         tags=["exc_source:api", f"type:{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:{} not allowed'.format(
                     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(f"JSON parse error ERR:{e} RAW:{raw_body!r}")
 
     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/apps/admin/tests/test_admin_audit_logs.py

@@ -1,172 +1,156 b''
 
 # 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 csv
 import datetime
 
 import pytest
 
 from rhodecode.lib.str_utils import safe_str
 from rhodecode.tests import *
+from rhodecode.tests.routes import route_path
 from rhodecode.tests.fixture import FIXTURES
 from rhodecode.model.db import UserLog
 from rhodecode.model.meta import Session
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'admin_home': ADMIN_PREFIX,
-        'admin_audit_logs': ADMIN_PREFIX + '/audit_logs',
-
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 @pytest.mark.usefixtures('app')
 class TestAdminController(object):
 
     @pytest.fixture(scope='class', autouse=True)
     def prepare(self, request, baseapp):
         UserLog.query().delete()
         Session().commit()
 
         def strptime(val):
             fmt = '%Y-%m-%d %H:%M:%S'
             if '.' not in val:
                 return datetime.datetime.strptime(val, fmt)
 
             nofrag, frag = val.split(".")
             date = datetime.datetime.strptime(nofrag, fmt)
 
             frag = frag[:6]  # truncate to microseconds
             frag += (6 - len(frag)) * '0'  # add 0s
             return date.replace(microsecond=int(frag))
 
         with open(os.path.join(FIXTURES, 'journal_dump.csv')) as f:
             for row in csv.DictReader(f):
                 ul = UserLog()
                 for k, v in row.items():
                     v = safe_str(v)
                     if k == 'action_date':
                         v = strptime(v)
                     if k in ['user_id', 'repository_id']:
                         # nullable due to FK problems
                         v = None
                     setattr(ul, k, v)
                 Session().add(ul)
             Session().commit()
 
         @request.addfinalizer
         def cleanup():
             UserLog.query().delete()
             Session().commit()
 
     def test_index(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs'))
         response.mustcontain('Admin audit logs')
 
     def test_filter_all_entries(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs'))
         all_count = UserLog.query().count()
         response.mustcontain('%s entries' % all_count)
 
     def test_filter_journal_filter_exact_match_on_repository(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='repository:rhodecode')))
         response.mustcontain('3 entries')
 
     def test_filter_journal_filter_exact_match_on_repository_CamelCase(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='repository:RhodeCode')))
         response.mustcontain('3 entries')
 
     def test_filter_journal_filter_wildcard_on_repository(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='repository:*test*')))
         response.mustcontain('862 entries')
 
     def test_filter_journal_filter_prefix_on_repository(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='repository:test*')))
         response.mustcontain('257 entries')
 
     def test_filter_journal_filter_prefix_on_repository_CamelCase(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='repository:Test*')))
         response.mustcontain('257 entries')
 
     def test_filter_journal_filter_prefix_on_repository_and_user(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='repository:test* AND username:demo')))
         response.mustcontain('130 entries')
 
     def test_filter_journal_filter_prefix_on_repository_or_target_repo(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='repository:test* OR repository:rhodecode')))
         response.mustcontain('260 entries')  # 257 + 3
 
     def test_filter_journal_filter_exact_match_on_username(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                params=dict(filter='username:demo')))
         response.mustcontain('1087 entries')
 
     def test_filter_journal_filter_exact_match_on_username_camelCase(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='username:DemO')))
         response.mustcontain('1087 entries')
 
     def test_filter_journal_filter_wildcard_on_username(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='username:*test*')))
         entries_count = UserLog.query().filter(UserLog.username.ilike('%test%')).count()
         response.mustcontain('{} entries'.format(entries_count))
 
     def test_filter_journal_filter_prefix_on_username(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='username:demo*')))
         response.mustcontain('1101 entries')
 
     def test_filter_journal_filter_prefix_on_user_or_other_user(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='username:demo OR username:volcan')))
         response.mustcontain('1095 entries')  # 1087 + 8
 
     def test_filter_journal_filter_wildcard_on_action(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='action:*pull_request*')))
         response.mustcontain('187 entries')
 
     def test_filter_journal_filter_on_date(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='date:20121010')))
         response.mustcontain('47 entries')
 
     def test_filter_journal_filter_on_date_2(self, autologin_user):
         response = self.app.get(route_path('admin_audit_logs',
                                 params=dict(filter='date:20121020')))
         response.mustcontain('17 entries')

rhodecode/apps/admin/tests/test_admin_defaults.py

@@ -1,86 +1,69 b''
 
 # 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 assert_session_flash
+from rhodecode.tests.routes import route_path
 from rhodecode.model.settings import SettingsModel
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'admin_defaults_repositories':
-            ADMIN_PREFIX + '/defaults/repositories',
-        'admin_defaults_repositories_update':
-            ADMIN_PREFIX + '/defaults/repositories/update',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 @pytest.mark.usefixtures("app")
 class TestDefaultsView(object):
 
     def test_index(self, autologin_user):
         response = self.app.get(route_path('admin_defaults_repositories'))
         response.mustcontain('default_repo_private')
         response.mustcontain('default_repo_enable_statistics')
         response.mustcontain('default_repo_enable_downloads')
         response.mustcontain('default_repo_enable_locking')
 
     def test_update_params_true_hg(self, autologin_user, csrf_token):
         params = {
             'default_repo_enable_locking': True,
             'default_repo_enable_downloads': True,
             'default_repo_enable_statistics': True,
             'default_repo_private': True,
             'default_repo_type': 'hg',
             'csrf_token': csrf_token,
         }
         response = self.app.post(
             route_path('admin_defaults_repositories_update'), params=params)
         assert_session_flash(response, 'Default settings updated successfully')
 
         defs = SettingsModel().get_default_repo_settings()
         del params['csrf_token']
         assert params == defs
 
     def test_update_params_false_git(self, autologin_user, csrf_token):
         params = {
             'default_repo_enable_locking': False,
             'default_repo_enable_downloads': False,
             'default_repo_enable_statistics': False,
             'default_repo_private': False,
             'default_repo_type': 'git',
             'csrf_token': csrf_token,
         }
         response = self.app.post(
             route_path('admin_defaults_repositories_update'), params=params)
         assert_session_flash(response, 'Default settings updated successfully')
 
         defs = SettingsModel().get_default_repo_settings()
         del params['csrf_token']
         assert params == defs

rhodecode/apps/admin/tests/test_admin_main_views.py

@@ -1,86 +1,67 b''
 
 # 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 TestController
 from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'admin_home': ADMIN_PREFIX,
-        'pullrequest_show': '/{repo_name}/pull-request/{pull_request_id}',
-        'pull_requests_global': ADMIN_PREFIX + '/pull-request/{pull_request_id}',
-        'pull_requests_global_0': ADMIN_PREFIX + '/pull_requests/{pull_request_id}',
-        'pull_requests_global_1': ADMIN_PREFIX + '/pull-requests/{pull_request_id}',
-
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 class TestAdminMainView(TestController):
 
     def test_access_admin_home(self):
         self.log_user()
         response = self.app.get(route_path('admin_home'), status=200)
         response.mustcontain("Administration area")
 
     @pytest.mark.parametrize('view', [
         'pull_requests_global',
     ])
     def test_redirect_pull_request_view_global(self, view):
         self.log_user()
         self.app.get(
             route_path(view, pull_request_id='xxxx'),
             status=404)
 
     @pytest.mark.backends("git", "hg")
     @pytest.mark.parametrize('view', [
         'pull_requests_global',
         'pull_requests_global_0',
         'pull_requests_global_1',
     ])
     def test_redirect_pull_request_view(self, view, pr_util):
         self.log_user()
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
         repo_name = pull_request.target_repo.repo_name
 
         response = self.app.get(
             route_path(view, pull_request_id=pull_request_id),
             status=302)
         assert response.location.endswith(
             'pull-request/{}'.format(pull_request_id))
 
         redirect_url = route_path(
             'pullrequest_show', repo_name=repo_name,
             pull_request_id=pull_request_id)
 
         assert redirect_url in response.location

rhodecode/apps/admin/tests/test_admin_permissions.py

@@ -1,300 +1,253 b''
 
 # 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, UserIpMap
 from rhodecode.model.meta import Session
 from rhodecode.model.permission import PermissionModel
 from rhodecode.model.ssh_key import SshKeyModel
 from rhodecode.tests import (
     TestController, clear_cache_regions, assert_session_flash)
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'edit_user_ips':
-            ADMIN_PREFIX + '/users/{user_id}/edit/ips',
-        'edit_user_ips_add':
-            ADMIN_PREFIX + '/users/{user_id}/edit/ips/new',
-        'edit_user_ips_delete':
-            ADMIN_PREFIX + '/users/{user_id}/edit/ips/delete',
-
-        'admin_permissions_application':
-            ADMIN_PREFIX + '/permissions/application',
-        'admin_permissions_application_update':
-            ADMIN_PREFIX + '/permissions/application/update',
-
-        'admin_permissions_global':
-            ADMIN_PREFIX + '/permissions/global',
-        'admin_permissions_global_update':
-            ADMIN_PREFIX + '/permissions/global/update',
-
-        'admin_permissions_object':
-            ADMIN_PREFIX + '/permissions/object',
-        'admin_permissions_object_update':
-            ADMIN_PREFIX + '/permissions/object/update',
-
-        'admin_permissions_ips':
-            ADMIN_PREFIX + '/permissions/ips',
-        'admin_permissions_overview':
-            ADMIN_PREFIX + '/permissions/overview',
-
-        'admin_permissions_ssh_keys':
-            ADMIN_PREFIX + '/permissions/ssh_keys',
-        'admin_permissions_ssh_keys_data':
-            ADMIN_PREFIX + '/permissions/ssh_keys/data',
-        'admin_permissions_ssh_keys_update':
-            ADMIN_PREFIX + '/permissions/ssh_keys/update'
-
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests.routes import route_path
 
 
 class TestAdminPermissionsController(TestController):
 
     @pytest.fixture(scope='class', autouse=True)
     def prepare(self, request):
         # cleanup and reset to default permissions after
         @request.addfinalizer
         def cleanup():
             PermissionModel().create_default_user_permissions(
                 User.get_default_user(), force=True)
 
     def test_index_application(self):
         self.log_user()
         self.app.get(route_path('admin_permissions_application'))
 
     @pytest.mark.parametrize(
         'anonymous, default_register, default_register_message, default_password_reset,' 
         'default_extern_activate, expect_error, expect_form_error', [
             (True, 'hg.register.none', '', 'hg.password_reset.enabled', 'hg.extern_activate.manual',
              False, False),
             (True, 'hg.register.manual_activate', '', 'hg.password_reset.enabled', 'hg.extern_activate.auto',
              False, False),
             (True, 'hg.register.auto_activate', '', 'hg.password_reset.enabled', 'hg.extern_activate.manual',
              False, False),
             (True, 'hg.register.auto_activate', '', 'hg.password_reset.enabled', 'hg.extern_activate.manual',
              False, False),
             (True, 'hg.register.XXX', '', 'hg.password_reset.enabled', 'hg.extern_activate.manual',
              False, True),
             (True, '', '', 'hg.password_reset.enabled', '', True, False),
         ])
     def test_update_application_permissions(
             self, anonymous, default_register, default_register_message, default_password_reset,
             default_extern_activate, expect_error, expect_form_error):
 
         self.log_user()
 
         # TODO: anonymous access set here to False, breaks some other tests
         params = {
             'csrf_token': self.csrf_token,
             'anonymous': anonymous,
             'default_register': default_register,
             'default_register_message': default_register_message,
             'default_password_reset': default_password_reset,
             'default_extern_activate': default_extern_activate,
         }
         response = self.app.post(route_path('admin_permissions_application_update'),
                                  params=params)
         if expect_form_error:
             assert response.status_int == 200
             response.mustcontain('Value must be one of')
         else:
             if expect_error:
                 msg = 'Error occurred during update of permissions'
             else:
                 msg = 'Application permissions updated successfully'
             assert_session_flash(response, msg)
 
     def test_index_object(self):
         self.log_user()
         self.app.get(route_path('admin_permissions_object'))
 
     @pytest.mark.parametrize(
         'repo, repo_group, user_group, expect_error, expect_form_error', [
             ('repository.none', 'group.none', 'usergroup.none', False, False),
             ('repository.read', 'group.read', 'usergroup.read', False, False),
             ('repository.write', 'group.write', 'usergroup.write',
              False, False),
             ('repository.admin', 'group.admin', 'usergroup.admin',
              False, False),
             ('repository.XXX', 'group.admin', 'usergroup.admin', False, True),
             ('', '', '', True, False),
         ])
     def test_update_object_permissions(self, repo, repo_group, user_group,
                                        expect_error, expect_form_error):
         self.log_user()
 
         params = {
             'csrf_token': self.csrf_token,
             'default_repo_perm': repo,
             'overwrite_default_repo': False,
             'default_group_perm': repo_group,
             'overwrite_default_group': False,
             'default_user_group_perm': user_group,
             'overwrite_default_user_group': False,
         }
         response = self.app.post(route_path('admin_permissions_object_update'),
                                  params=params)
         if expect_form_error:
             assert response.status_int == 200
             response.mustcontain('Value must be one of')
         else:
             if expect_error:
                 msg = 'Error occurred during update of permissions'
             else:
                 msg = 'Object permissions updated successfully'
             assert_session_flash(response, msg)
 
     def test_index_global(self):
         self.log_user()
         self.app.get(route_path('admin_permissions_global'))
 
     @pytest.mark.parametrize(
         'repo_create, repo_create_write, user_group_create, repo_group_create,'
         'fork_create, inherit_default_permissions, expect_error,'
         'expect_form_error', [
             ('hg.create.none', 'hg.create.write_on_repogroup.false',
              'hg.usergroup.create.false', 'hg.repogroup.create.false',
              'hg.fork.none', 'hg.inherit_default_perms.false', False, False),
             ('hg.create.repository', 'hg.create.write_on_repogroup.true',
              'hg.usergroup.create.true', 'hg.repogroup.create.true',
              'hg.fork.repository', 'hg.inherit_default_perms.false',
              False, False),
             ('hg.create.XXX', 'hg.create.write_on_repogroup.true',
              'hg.usergroup.create.true', 'hg.repogroup.create.true',
              'hg.fork.repository', 'hg.inherit_default_perms.false',
              False, True),
             ('', '', '', '', '', '', True, False),
         ])
     def test_update_global_permissions(
             self, repo_create, repo_create_write, user_group_create,
             repo_group_create, fork_create, inherit_default_permissions,
             expect_error, expect_form_error):
         self.log_user()
 
         params = {
             'csrf_token': self.csrf_token,
             'default_repo_create': repo_create,
             'default_repo_create_on_write': repo_create_write,
             'default_user_group_create': user_group_create,
             'default_repo_group_create': repo_group_create,
             'default_fork_create': fork_create,
             'default_inherit_default_permissions': inherit_default_permissions
         }
         response = self.app.post(route_path('admin_permissions_global_update'),
                                  params=params)
         if expect_form_error:
             assert response.status_int == 200
             response.mustcontain('Value must be one of')
         else:
             if expect_error:
                 msg = 'Error occurred during update of permissions'
             else:
                 msg = 'Global permissions updated successfully'
             assert_session_flash(response, msg)
 
     def test_index_ips(self):
         self.log_user()
         response = self.app.get(route_path('admin_permissions_ips'))
         response.mustcontain('All IP addresses are allowed')
 
     def test_add_delete_ips(self):
         clear_cache_regions(['sql_cache_short'])
         self.log_user()
 
         # ADD
         default_user_id = User.get_default_user_id()
         self.app.post(
             route_path('edit_user_ips_add', user_id=default_user_id),
             params={'new_ip': '0.0.0.0/24', 'csrf_token': self.csrf_token})
 
         response = self.app.get(route_path('admin_permissions_ips'))
         response.mustcontain('0.0.0.0/24')
         response.mustcontain('0.0.0.0 - 0.0.0.255')
 
         # DELETE
         default_user_id = User.get_default_user_id()
         del_ip_id = UserIpMap.query().filter(UserIpMap.user_id ==
                                              default_user_id).first().ip_id
 
         response = self.app.post(
             route_path('edit_user_ips_delete', user_id=default_user_id),
             params={'del_ip_id': del_ip_id, 'csrf_token': self.csrf_token})
 
         assert_session_flash(response, 'Removed ip address from user whitelist')
 
         clear_cache_regions(['sql_cache_short'])
         response = self.app.get(route_path('admin_permissions_ips'))
         response.mustcontain('All IP addresses are allowed')
         response.mustcontain(no=['0.0.0.0/24'])
         response.mustcontain(no=['0.0.0.0 - 0.0.0.255'])
 
     def test_index_overview(self):
         self.log_user()
         self.app.get(route_path('admin_permissions_overview'))
 
     def test_ssh_keys(self):
         self.log_user()
         self.app.get(route_path('admin_permissions_ssh_keys'), status=200)
 
     def test_ssh_keys_data(self, user_util, xhr_header):
         self.log_user()
         response = self.app.get(route_path('admin_permissions_ssh_keys_data'),
                                 extra_environ=xhr_header)
         assert response.json == {u'data': [], u'draw': None,
                                  u'recordsFiltered': 0, u'recordsTotal': 0}
 
         dummy_user = user_util.create_user()
         SshKeyModel().create(dummy_user, 'ab:cd:ef', 'KEYKEY', 'test_key')
         Session().commit()
         response = self.app.get(route_path('admin_permissions_ssh_keys_data'),
                                 extra_environ=xhr_header)
         assert response.json['data'][0]['fingerprint'] == 'ab:cd:ef'
 
     def test_ssh_keys_update(self):
         self.log_user()
         response = self.app.post(
             route_path('admin_permissions_ssh_keys_update'),
             dict(csrf_token=self.csrf_token), status=302)
 
         assert_session_flash(
             response, 'Updated SSH keys file')
 
     def test_ssh_keys_update_disabled(self):
         self.log_user()
 
         from rhodecode.apps.admin.views.permissions import AdminPermissionsView
         with mock.patch.object(AdminPermissionsView, 'ssh_enabled',
                                return_value=False):
             response = self.app.post(
                 route_path('admin_permissions_ssh_keys_update'),
                 dict(csrf_token=self.csrf_token), status=302)
 
             assert_session_flash(
                 response, 'SSH key support is disabled in .ini file')
  No newline at end of file

rhodecode/apps/admin/tests/test_admin_repos.py

@@ -1,515 +1,497 b''
 
 # 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 urllib.request
 import urllib.parse
 import urllib.error
 
 import mock
 import pytest
 
 from rhodecode.apps._base import ADMIN_PREFIX
 from rhodecode.lib import auth
 from rhodecode.lib.utils2 import safe_str
 from rhodecode.lib import helpers as h
 from rhodecode.model.db import (
     Repository, RepoGroup, UserRepoToPerm, User, Permission)
 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 (
     login_user_session, assert_session_flash, TEST_USER_ADMIN_LOGIN,
     TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
 from rhodecode.tests.fixture import Fixture, error_function
-from rhodecode.tests.utils import AssertResponse, repo_on_filesystem
+from rhodecode.tests.utils import repo_on_filesystem
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'repos': ADMIN_PREFIX + '/repos',
-        'repos_data': ADMIN_PREFIX + '/repos_data',
-        'repo_new': ADMIN_PREFIX + '/repos/new',
-        'repo_create': ADMIN_PREFIX + '/repos/create',
-
-        'repo_creating_check': '/{repo_name}/repo_creating_check',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 def _get_permission_for_user(user, repo):
     perm = UserRepoToPerm.query()\
         .filter(UserRepoToPerm.repository ==
                 Repository.get_by_repo_name(repo))\
         .filter(UserRepoToPerm.user == User.get_by_username(user))\
         .all()
     return perm
 
 
 @pytest.mark.usefixtures("app")
 class TestAdminRepos(object):
 
     def test_repo_list(self, autologin_user, user_util, xhr_header):
         repo = user_util.create_repo()
         repo_name = repo.repo_name
         response = self.app.get(
             route_path('repos_data'), status=200,
             extra_environ=xhr_header)
 
         response.mustcontain(repo_name)
 
     def test_create_page_restricted_to_single_backend(self, autologin_user, backend):
         with mock.patch('rhodecode.BACKENDS', {'git': 'git'}):
             response = self.app.get(route_path('repo_new'), status=200)
         assert_response = response.assert_response()
         element = assert_response.get_element('[name=repo_type]')
         assert element.get('value') == 'git'
 
     def test_create_page_non_restricted_backends(self, autologin_user, backend):
         response = self.app.get(route_path('repo_new'), status=200)
         assert_response = response.assert_response()
         assert ['hg', 'git', 'svn'] == [x.get('value') for x in assert_response.get_elements('[name=repo_type]')]
 
     @pytest.mark.parametrize(
         "suffix", ['', 'xxa'], ids=['', 'non-ascii'])
     def test_create(self, autologin_user, backend, suffix, csrf_token):
         repo_name_unicode = backend.new_repo_name(suffix=suffix)
         repo_name = repo_name_unicode
 
         description_unicode = 'description for newly created repo' + suffix
         description = description_unicode
 
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token),
             status=302)
 
         self.assert_repository_is_created_correctly(
             repo_name, description, backend)
 
     def test_create_numeric_name(self, autologin_user, backend, csrf_token):
         numeric_repo = '1234'
         repo_name = numeric_repo
         description = 'description for newly created repo' + numeric_repo
         self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
 
         self.assert_repository_is_created_correctly(
             repo_name, description, backend)
 
     @pytest.mark.parametrize("suffix", ['', '_ąćę'], ids=['', 'non-ascii'])
     def test_create_in_group(
             self, autologin_user, backend, suffix, csrf_token):
         # create GROUP
         group_name = f'sometest_{backend.alias}'
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
 
         repo_name = f'ingroup{suffix}'
         repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])
         description = 'description for newly created repo'
 
         self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=safe_str(repo_name),
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=gr.group_id,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup work to fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
 
             new_repo = RepoModel().get_by_repo_name(repo_name_full)
             inherited_perms = UserRepoToPerm.query().filter(
                 UserRepoToPerm.repository_id == new_repo.repo_id).all()
             assert len(inherited_perms) == 1
         finally:
             RepoModel().delete(repo_name_full)
             RepoGroupModel().delete(group_name)
             Session().commit()
 
     def test_create_in_group_numeric_name(
             self, autologin_user, backend, csrf_token):
         # create GROUP
         group_name = 'sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
 
         repo_name = '12345'
         repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])
         description = 'description for newly created repo'
         self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=gr.group_id,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup work to fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
 
             new_repo = RepoModel().get_by_repo_name(repo_name_full)
             inherited_perms = UserRepoToPerm.query()\
                 .filter(UserRepoToPerm.repository_id == new_repo.repo_id).all()
             assert len(inherited_perms) == 1
         finally:
             RepoModel().delete(repo_name_full)
             RepoGroupModel().delete(group_name)
             Session().commit()
 
     def test_create_in_group_without_needed_permissions(self, backend):
         session = login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         csrf_token = auth.get_csrf_token(session)
         # revoke
         user_model = UserModel()
         # disable fork and create on default user
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.create.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.create.none')
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.fork.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.fork.none')
 
         # disable on regular user
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.none')
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.none')
         Session().commit()
 
         # create GROUP
         group_name = 'reg_sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
         repo_group_id = gr.group_id
 
         group_name_allowed = 'reg_sometest_allowed_%s' % backend.alias
         gr_allowed = RepoGroupModel().create(
             group_name=group_name_allowed,
             group_description='test',
             owner=TEST_USER_REGULAR_LOGIN)
         allowed_repo_group_id = gr_allowed.group_id
         Session().commit()
 
         repo_name = 'ingroup'
         description = 'description for newly created repo'
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=repo_group_id,
                 csrf_token=csrf_token))
 
         response.mustcontain('Invalid value')
 
         # user is allowed to create in this group
         repo_name = 'ingroup'
         repo_name_full = RepoGroup.url_sep().join(
             [group_name_allowed, repo_name])
         description = 'description for newly created repo'
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=allowed_repo_group_id,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup in pytest fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
 
             new_repo = RepoModel().get_by_repo_name(repo_name_full)
             inherited_perms = UserRepoToPerm.query().filter(
                 UserRepoToPerm.repository_id == new_repo.repo_id).all()
             assert len(inherited_perms) == 1
 
             assert repo_on_filesystem(repo_name_full)
         finally:
             RepoModel().delete(repo_name_full)
             RepoGroupModel().delete(group_name)
             RepoGroupModel().delete(group_name_allowed)
             Session().commit()
 
     def test_create_in_group_inherit_permissions(self, autologin_user, backend,
                                                  csrf_token):
         # create GROUP
         group_name = 'sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         perm = Permission.get_by_key('repository.write')
         RepoGroupModel().grant_user_permission(
             gr, TEST_USER_REGULAR_LOGIN, perm)
 
         # add repo permissions
         Session().commit()
         repo_group_id = gr.group_id
         repo_name = 'ingroup_inherited_%s' % backend.alias
         repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])
         description = 'description for newly created repo'
         self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=repo_group_id,
                 repo_copy_permissions=True,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup to pytest fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
         except Exception:
             RepoGroupModel().delete(group_name)
             Session().commit()
             raise
 
         # check if inherited permissions are applied
         new_repo = RepoModel().get_by_repo_name(repo_name_full)
         inherited_perms = UserRepoToPerm.query().filter(
             UserRepoToPerm.repository_id == new_repo.repo_id).all()
         assert len(inherited_perms) == 2
 
         assert TEST_USER_REGULAR_LOGIN in [
             x.user.username for x in inherited_perms]
         assert 'repository.write' in [
             x.permission.permission_name for x in inherited_perms]
 
         RepoModel().delete(repo_name_full)
         RepoGroupModel().delete(group_name)
         Session().commit()
 
     @pytest.mark.xfail_backends(
         "git", "hg", reason="Missing reposerver support")
     def test_create_with_clone_uri(self, autologin_user, backend, reposerver,
                                    csrf_token):
         source_repo = backend.create_repo(number_of_commits=2)
         source_repo_name = source_repo.repo_name
         reposerver.serve(source_repo.scm_instance())
 
         repo_name = backend.new_repo_name()
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description='',
                 clone_uri=reposerver.url,
                 csrf_token=csrf_token),
             status=302)
 
         # Should be redirected to the creating page
         response.mustcontain('repo_creating')
 
         # Expecting that both repositories have same history
         source_repo = RepoModel().get_by_repo_name(source_repo_name)
         source_vcs = source_repo.scm_instance()
         repo = RepoModel().get_by_repo_name(repo_name)
         repo_vcs = repo.scm_instance()
         assert source_vcs[0].message == repo_vcs[0].message
         assert source_vcs.count() == repo_vcs.count()
         assert source_vcs.commit_ids == repo_vcs.commit_ids
 
     @pytest.mark.xfail_backends("svn", reason="Depends on import support")
     def test_create_remote_repo_wrong_clone_uri(self, autologin_user, backend,
                                                 csrf_token):
         repo_name = backend.new_repo_name()
         description = 'description for newly created repo'
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 clone_uri='http://repo.invalid/repo',
                 csrf_token=csrf_token))
         response.mustcontain('invalid clone url')
 
     @pytest.mark.xfail_backends("svn", reason="Depends on import support")
     def test_create_remote_repo_wrong_clone_uri_hg_svn(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.new_repo_name()
         description = 'description for newly created repo'
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 clone_uri='svn+http://svn.invalid/repo',
                 csrf_token=csrf_token))
         response.mustcontain('invalid clone url')
 
     def test_create_with_git_suffix(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.new_repo_name() + ".git"
         description = 'description for newly created repo'
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
         response.mustcontain('Repository name cannot end with .git')
 
     def test_default_user_cannot_access_private_repo_in_a_group(
             self, autologin_user, user_util, backend):
 
         group = user_util.create_repo_group()
 
         repo = backend.create_repo(
             repo_private=True, repo_group=group, repo_copy_permissions=True)
 
         permissions = _get_permission_for_user(
             user='default', repo=repo.repo_name)
         assert len(permissions) == 1
         assert permissions[0].permission.permission_name == 'repository.none'
         assert permissions[0].repository.private is True
 
     def test_create_on_top_level_without_permissions(self, backend):
         session = login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         csrf_token = auth.get_csrf_token(session)
 
         # revoke
         user_model = UserModel()
         # disable fork and create on default user
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.create.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.create.none')
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.fork.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.fork.none')
 
         # disable on regular user
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.none')
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.none')
         Session().commit()
 
         repo_name = backend.new_repo_name()
         description = 'description for newly created repo'
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
 
         response.mustcontain(
             u"You do not have the permission to store repositories in "
             u"the root location.")
 
     @mock.patch.object(RepoModel, '_create_filesystem_repo', error_function)
     def test_create_repo_when_filesystem_op_fails(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.new_repo_name()
         description = 'description for newly created repo'
 
         response = self.app.post(
             route_path('repo_create'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
 
         assert_session_flash(
             response, 'Error creating repository %s' % repo_name)
         # repo must not be in db
         assert backend.repo is None
         # repo must not be in filesystem !
         assert not repo_on_filesystem(repo_name)
 
     def assert_repository_is_created_correctly(self, repo_name, description, backend):
         url_quoted_repo_name = urllib.parse.quote(repo_name)
 
         # run the check page that triggers the flash message
         response = self.app.get(
             route_path('repo_creating_check', repo_name=repo_name))
         assert response.json == {'result': True}
 
         flash_msg = 'Created repository <a href="/{}">{}</a>'.format(url_quoted_repo_name, repo_name)
         assert_session_flash(response, flash_msg)
 
         # test if the repo was created in the database
         new_repo = RepoModel().get_by_repo_name(repo_name)
 
         assert new_repo.repo_name == repo_name
         assert new_repo.description == description
 
         # test if the repository is visible in the list ?
         response = self.app.get(
             h.route_path('repo_summary', repo_name=repo_name))
         response.mustcontain(repo_name)
         response.mustcontain(backend.alias)
 
         assert repo_on_filesystem(repo_name)

rhodecode/apps/admin/tests/test_admin_repository_groups.py

@@ -1,195 +1,179 b''
 
 # 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.apps._base import ADMIN_PREFIX
 from rhodecode.lib import helpers as h
 from rhodecode.model.db import Repository, UserRepoToPerm, User, RepoGroup
 from rhodecode.model.meta import Session
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.tests import (
     assert_session_flash, TEST_USER_REGULAR_LOGIN, TESTS_TMP_PATH)
 from rhodecode.tests.fixture import Fixture
-
-fixture = Fixture()
+from rhodecode.tests.routes import route_path
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'repo_groups': ADMIN_PREFIX + '/repo_groups',
-        'repo_groups_data': ADMIN_PREFIX + '/repo_groups_data',
-        'repo_group_new': ADMIN_PREFIX + '/repo_group/new',
-        'repo_group_create': ADMIN_PREFIX + '/repo_group/create',
-
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+fixture = Fixture()
 
 
 def _get_permission_for_user(user, repo):
     perm = UserRepoToPerm.query()\
         .filter(UserRepoToPerm.repository ==
                 Repository.get_by_repo_name(repo))\
         .filter(UserRepoToPerm.user == User.get_by_username(user))\
         .all()
     return perm
 
 
 @pytest.mark.usefixtures("app")
 class TestAdminRepositoryGroups(object):
 
     def test_show_repo_groups(self, autologin_user):
         self.app.get(route_path('repo_groups'))
 
     def test_show_repo_groups_data(self, autologin_user, xhr_header):
         response = self.app.get(route_path(
             'repo_groups_data'), extra_environ=xhr_header)
 
         all_repo_groups = RepoGroup.query().count()
         assert response.json['recordsTotal'] == all_repo_groups
 
     def test_show_repo_groups_data_filtered(self, autologin_user, xhr_header):
         response = self.app.get(route_path(
             'repo_groups_data', params={'search[value]': 'empty_search'}),
             extra_environ=xhr_header)
 
         all_repo_groups = RepoGroup.query().count()
         assert response.json['recordsTotal'] == all_repo_groups
         assert response.json['recordsFiltered'] == 0
 
     def test_show_repo_groups_after_creating_group(self, autologin_user, xhr_header):
         fixture.create_repo_group('test_repo_group')
         response = self.app.get(route_path(
             'repo_groups_data'), extra_environ=xhr_header)
         response.mustcontain('<a href=\\"/{}/_edit\\" title=\\"Edit\\">Edit</a>'.format('test_repo_group'))
         fixture.destroy_repo_group('test_repo_group')
 
     def test_new(self, autologin_user):
         self.app.get(route_path('repo_group_new'))
 
     def test_new_with_parent_group(self, autologin_user, user_util):
         gr = user_util.create_repo_group()
 
         self.app.get(route_path('repo_group_new'),
                      params=dict(parent_group=gr.group_name))
 
     def test_new_by_regular_user_no_permission(self, autologin_regular_user):
         self.app.get(route_path('repo_group_new'), status=403)
 
     @pytest.mark.parametrize('repo_group_name', [
         'git_repo',
         'git_repo_ąć',
         'hg_repo',
         '12345',
         'hg_repo_ąć',
     ])
     def test_create(self, autologin_user, repo_group_name, csrf_token):
         repo_group_name_non_ascii = repo_group_name
         description = 'description for newly created repo group'
 
         response = self.app.post(
             route_path('repo_group_create'),
             fixture._get_group_create_params(
                 group_name=repo_group_name,
                 group_description=description,
                 csrf_token=csrf_token))
 
         # run the check page that triggers the flash message
         repo_gr_url = h.route_path(
             'repo_group_home', repo_group_name=repo_group_name)
 
         assert_session_flash(
             response,
             'Created repository group <a href="%s">%s</a>' % (
                 repo_gr_url, repo_group_name_non_ascii))
 
         # # test if the repo group was created in the database
         new_repo_group = RepoGroupModel()._get_repo_group(
             repo_group_name_non_ascii)
         assert new_repo_group is not None
 
         assert new_repo_group.group_name == repo_group_name_non_ascii
         assert new_repo_group.group_description == description
 
         # test if the repository is visible in the list ?
         response = self.app.get(repo_gr_url)
         response.mustcontain(repo_group_name)
 
         # test if the repository group was created on filesystem
         is_on_filesystem = os.path.isdir(
             os.path.join(TESTS_TMP_PATH, repo_group_name))
         if not is_on_filesystem:
             self.fail('no repo group %s in filesystem' % repo_group_name)
 
         RepoGroupModel().delete(repo_group_name_non_ascii)
         Session().commit()
 
     @pytest.mark.parametrize('repo_group_name', [
         'git_repo',
         'git_repo_ąć',
         'hg_repo',
         '12345',
         'hg_repo_ąć',
     ])
     def test_create_subgroup(self, autologin_user, user_util, repo_group_name, csrf_token):
         parent_group = user_util.create_repo_group()
         parent_group_name = parent_group.group_name
 
         expected_group_name = '{}/{}'.format(
             parent_group_name, repo_group_name)
         expected_group_name_non_ascii = expected_group_name
 
         try:
             response = self.app.post(
                 route_path('repo_group_create'),
                 fixture._get_group_create_params(
                     group_name=repo_group_name,
                     group_parent_id=parent_group.group_id,
                     group_description='Test desciption',
                     csrf_token=csrf_token))
 
             assert_session_flash(
                 response,
                 u'Created repository group <a href="%s">%s</a>' % (
                     h.route_path('repo_group_home',
                                  repo_group_name=expected_group_name),
                     expected_group_name_non_ascii))
         finally:
             RepoGroupModel().delete(expected_group_name_non_ascii)
             Session().commit()
 
     def test_user_with_creation_permissions_cannot_create_subgroups(
             self, autologin_regular_user, user_util):
 
         user_util.grant_user_permission(
             TEST_USER_REGULAR_LOGIN, 'hg.repogroup.create.true')
         parent_group = user_util.create_repo_group()
         parent_group_id = parent_group.group_id
         self.app.get(
             route_path('repo_group_new',
                        params=dict(parent_group=parent_group_id), ),
             status=403)

rhodecode/apps/admin/tests/test_admin_settings.py

@@ -1,768 +1,695 b''
 
 # 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
 
 import rhodecode
 from rhodecode.apps._base import ADMIN_PREFIX
 from rhodecode.lib.hash_utils import md5_safe
 from rhodecode.model.db import RhodeCodeUi
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel, IssueTrackerSettingsModel
 from rhodecode.tests import assert_session_flash
+from rhodecode.tests.routes import route_path
 
 
 UPDATE_DATA_QUALNAME = 'rhodecode.model.update.UpdateModel.get_update_data'
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-
-        'admin_settings':
-            ADMIN_PREFIX +'/settings',
-        'admin_settings_update':
-            ADMIN_PREFIX + '/settings/update',
-        'admin_settings_global':
-            ADMIN_PREFIX + '/settings/global',
-        'admin_settings_global_update':
-            ADMIN_PREFIX + '/settings/global/update',
-        'admin_settings_vcs':
-            ADMIN_PREFIX + '/settings/vcs',
-        'admin_settings_vcs_update':
-            ADMIN_PREFIX + '/settings/vcs/update',
-        'admin_settings_vcs_svn_pattern_delete':
-            ADMIN_PREFIX + '/settings/vcs/svn_pattern_delete',
-        'admin_settings_mapping':
-            ADMIN_PREFIX + '/settings/mapping',
-        'admin_settings_mapping_update':
-            ADMIN_PREFIX + '/settings/mapping/update',
-        'admin_settings_visual':
-            ADMIN_PREFIX + '/settings/visual',
-        'admin_settings_visual_update':
-            ADMIN_PREFIX + '/settings/visual/update',
-        'admin_settings_issuetracker':
-            ADMIN_PREFIX + '/settings/issue-tracker',
-        'admin_settings_issuetracker_update':
-            ADMIN_PREFIX + '/settings/issue-tracker/update',
-        'admin_settings_issuetracker_test':
-            ADMIN_PREFIX + '/settings/issue-tracker/test',
-        'admin_settings_issuetracker_delete':
-            ADMIN_PREFIX + '/settings/issue-tracker/delete',
-        'admin_settings_email':
-            ADMIN_PREFIX + '/settings/email',
-        'admin_settings_email_update':
-            ADMIN_PREFIX + '/settings/email/update',
-        'admin_settings_hooks':
-            ADMIN_PREFIX + '/settings/hooks',
-        'admin_settings_hooks_update':
-            ADMIN_PREFIX + '/settings/hooks/update',
-        'admin_settings_hooks_delete':
-            ADMIN_PREFIX + '/settings/hooks/delete',
-        'admin_settings_search':
-            ADMIN_PREFIX + '/settings/search',
-        'admin_settings_labs':
-            ADMIN_PREFIX + '/settings/labs',
-        'admin_settings_labs_update':
-            ADMIN_PREFIX + '/settings/labs/update',
-
-        'admin_settings_sessions':
-            ADMIN_PREFIX + '/settings/sessions',
-        'admin_settings_sessions_cleanup':
-            ADMIN_PREFIX + '/settings/sessions/cleanup',
-        'admin_settings_system':
-            ADMIN_PREFIX + '/settings/system',
-        'admin_settings_system_update':
-            ADMIN_PREFIX + '/settings/system/updates',
-        'admin_settings_open_source':
-            ADMIN_PREFIX + '/settings/open_source',
-
-
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminSettingsController(object):
 
     @pytest.mark.parametrize('urlname', [
         'admin_settings_vcs',
         'admin_settings_mapping',
         'admin_settings_global',
         'admin_settings_visual',
         'admin_settings_email',
         'admin_settings_hooks',
         'admin_settings_search',
     ])
     def test_simple_get(self, urlname):
         self.app.get(route_path(urlname))
 
     def test_create_custom_hook(self, csrf_token):
         response = self.app.post(
             route_path('admin_settings_hooks_update'),
             params={
                 'new_hook_ui_key': 'test_hooks_1',
                 'new_hook_ui_value': 'cd /tmp',
                 'csrf_token': csrf_token})
 
         response = response.follow()
         response.mustcontain('test_hooks_1')
         response.mustcontain('cd /tmp')
 
     def test_create_custom_hook_delete(self, csrf_token):
         response = self.app.post(
             route_path('admin_settings_hooks_update'),
             params={
                 'new_hook_ui_key': 'test_hooks_2',
                 'new_hook_ui_value': 'cd /tmp2',
                 'csrf_token': csrf_token})
 
         response = response.follow()
         response.mustcontain('test_hooks_2')
         response.mustcontain('cd /tmp2')
 
         hook_id = SettingsModel().get_ui_by_key('test_hooks_2').ui_id
 
         # delete
         self.app.post(
             route_path('admin_settings_hooks_delete'),
             params={'hook_id': hook_id, 'csrf_token': csrf_token})
         response = self.app.get(route_path('admin_settings_hooks'))
         response.mustcontain(no=['test_hooks_2'])
         response.mustcontain(no=['cd /tmp2'])
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminSettingsGlobal(object):
 
     def test_pre_post_code_code_active(self, csrf_token):
         pre_code = 'rc-pre-code-187652122'
         post_code = 'rc-postcode-98165231'
 
         response = self.post_and_verify_settings({
             'rhodecode_pre_code': pre_code,
             'rhodecode_post_code': post_code,
             'csrf_token': csrf_token,
         })
 
         response = response.follow()
         response.mustcontain(pre_code, post_code)
 
     def test_pre_post_code_code_inactive(self, csrf_token):
         pre_code = 'rc-pre-code-187652122'
         post_code = 'rc-postcode-98165231'
         response = self.post_and_verify_settings({
             'rhodecode_pre_code': '',
             'rhodecode_post_code': '',
             'csrf_token': csrf_token,
         })
 
         response = response.follow()
         response.mustcontain(no=[pre_code, post_code])
 
     def test_captcha_activate(self, csrf_token):
         self.post_and_verify_settings({
             'rhodecode_captcha_private_key': '1234567890',
             'rhodecode_captcha_public_key': '1234567890',
             'csrf_token': csrf_token,
         })
 
         response = self.app.get(ADMIN_PREFIX + '/register')
         response.mustcontain('captcha')
 
     def test_captcha_deactivate(self, csrf_token):
         self.post_and_verify_settings({
             'rhodecode_captcha_private_key': '',
             'rhodecode_captcha_public_key': '1234567890',
             'csrf_token': csrf_token,
         })
 
         response = self.app.get(ADMIN_PREFIX + '/register')
         response.mustcontain(no=['captcha'])
 
     def test_title_change(self, csrf_token):
         old_title = 'RhodeCode'
 
         for new_title in ['Changed', 'Żółwik', old_title]:
             response = self.post_and_verify_settings({
                 'rhodecode_title': new_title,
                 'csrf_token': csrf_token,
             })
 
             response = response.follow()
             response.mustcontain(new_title)
 
     def post_and_verify_settings(self, settings):
         old_title = 'RhodeCode'
         old_realm = 'RhodeCode authentication'
         params = {
             'rhodecode_title': old_title,
             'rhodecode_realm': old_realm,
             'rhodecode_pre_code': '',
             'rhodecode_post_code': '',
             'rhodecode_captcha_private_key': '',
             'rhodecode_captcha_public_key': '',
             'rhodecode_create_personal_repo_group': False,
             'rhodecode_personal_repo_group_pattern': '${username}',
         }
         params.update(settings)
         response = self.app.post(
             route_path('admin_settings_global_update'), params=params)
 
         assert_session_flash(response, 'Updated application settings')
 
         app_settings = SettingsModel().get_all_settings()
         del settings['csrf_token']
         for key, value in settings.items():
             assert app_settings[key] == value
 
         return response
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminSettingsVcs(object):
 
     def test_contains_svn_default_patterns(self):
         response = self.app.get(route_path('admin_settings_vcs'))
         expected_patterns = [
             '/trunk',
             '/branches/*',
             '/tags/*',
         ]
         for pattern in expected_patterns:
             response.mustcontain(pattern)
 
     def test_add_new_svn_branch_and_tag_pattern(
             self, backend_svn, form_defaults, disable_sql_cache,
             csrf_token):
         form_defaults.update({
             'new_svn_branch': '/exp/branches/*',
             'new_svn_tag': '/important_tags/*',
             'csrf_token': csrf_token,
         })
 
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params=form_defaults, status=302)
         response = response.follow()
 
         # Expect to find the new values on the page
         response.mustcontain('/exp/branches/*')
         response.mustcontain('/important_tags/*')
 
         # Expect that those patterns are used to match branches and tags now
         repo = backend_svn['svn-simple-layout'].scm_instance()
         assert 'exp/branches/exp-sphinx-docs' in repo.branches
         assert 'important_tags/v0.5' in repo.tags
 
     def test_add_same_svn_value_twice_shows_an_error_message(
             self, form_defaults, csrf_token, settings_util):
         settings_util.create_rhodecode_ui('vcs_svn_branch', '/test')
         settings_util.create_rhodecode_ui('vcs_svn_tag', '/test')
 
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params={
                 'paths_root_path': form_defaults['paths_root_path'],
                 'new_svn_branch': '/test',
                 'new_svn_tag': '/test',
                 'csrf_token': csrf_token,
             },
             status=200)
 
         response.mustcontain("Pattern already exists")
         response.mustcontain("Some form inputs contain invalid data.")
 
     @pytest.mark.parametrize('section', [
         'vcs_svn_branch',
         'vcs_svn_tag',
     ])
     def test_delete_svn_patterns(
             self, section, csrf_token, settings_util):
         setting = settings_util.create_rhodecode_ui(
             section, '/test_delete', cleanup=False)
 
         self.app.post(
             route_path('admin_settings_vcs_svn_pattern_delete'),
             params={
                 'delete_svn_pattern': setting.ui_id,
                 'csrf_token': csrf_token},
             headers={'X-REQUESTED-WITH': 'XMLHttpRequest'})
 
     @pytest.mark.parametrize('section', [
         'vcs_svn_branch',
         'vcs_svn_tag',
     ])
     def test_delete_svn_patterns_raises_404_when_no_xhr(
             self, section, csrf_token, settings_util):
         setting = settings_util.create_rhodecode_ui(section, '/test_delete')
 
         self.app.post(
             route_path('admin_settings_vcs_svn_pattern_delete'),
             params={
                 'delete_svn_pattern': setting.ui_id,
                 'csrf_token': csrf_token},
             status=404)
 
     def test_extensions_hgsubversion(self, form_defaults, csrf_token):
         form_defaults.update({
             'csrf_token': csrf_token,
             'extensions_hgsubversion': 'True',
         })
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params=form_defaults,
             status=302)
 
         response = response.follow()
         extensions_input = (
             '<input id="extensions_hgsubversion" '
             'name="extensions_hgsubversion" type="checkbox" '
             'value="True" checked="checked" />')
         response.mustcontain(extensions_input)
 
     def test_extensions_hgevolve(self, form_defaults, csrf_token):
         form_defaults.update({
             'csrf_token': csrf_token,
             'extensions_evolve': 'True',
         })
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params=form_defaults,
             status=302)
 
         response = response.follow()
         extensions_input = (
             '<input id="extensions_evolve" '
             'name="extensions_evolve" type="checkbox" '
             'value="True" checked="checked" />')
         response.mustcontain(extensions_input)
 
     def test_has_a_section_for_pull_request_settings(self):
         response = self.app.get(route_path('admin_settings_vcs'))
         response.mustcontain('Pull Request Settings')
 
     def test_has_an_input_for_invalidation_of_inline_comments(self):
         response = self.app.get(route_path('admin_settings_vcs'))
         assert_response = response.assert_response()
         assert_response.one_element_exists(
             '[name=rhodecode_use_outdated_comments]')
 
     @pytest.mark.parametrize('new_value', [True, False])
     def test_allows_to_change_invalidation_of_inline_comments(
             self, form_defaults, csrf_token, new_value):
         setting_key = 'use_outdated_comments'
         setting = SettingsModel().create_or_update_setting(
             setting_key, not new_value, 'bool')
         Session().add(setting)
         Session().commit()
 
         form_defaults.update({
             'csrf_token': csrf_token,
             'rhodecode_use_outdated_comments': str(new_value),
         })
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params=form_defaults,
             status=302)
         response = response.follow()
         setting = SettingsModel().get_setting_by_name(setting_key)
         assert setting.app_settings_value is new_value
 
     @pytest.mark.parametrize('new_value', [True, False])
     def test_allows_to_change_hg_rebase_merge_strategy(
             self, form_defaults, csrf_token, new_value):
         setting_key = 'hg_use_rebase_for_merging'
 
         form_defaults.update({
             'csrf_token': csrf_token,
             'rhodecode_' + setting_key: str(new_value),
         })
 
         with mock.patch.dict(
                 rhodecode.CONFIG, {'labs_settings_active': 'true'}):
             self.app.post(
                 route_path('admin_settings_vcs_update'),
                 params=form_defaults,
                 status=302)
 
         setting = SettingsModel().get_setting_by_name(setting_key)
         assert setting.app_settings_value is new_value
 
     @pytest.fixture()
     def disable_sql_cache(self, request):
         # patch _do_orm_execute so it returns None similar like if we don't use a cached query
         patcher = mock.patch(
             'rhodecode.lib.caching_query.ORMCache._do_orm_execute', return_value=None)
         request.addfinalizer(patcher.stop)
         patcher.start()
 
     @pytest.fixture()
     def form_defaults(self):
         from rhodecode.apps.admin.views.settings import AdminSettingsView
         return AdminSettingsView._form_defaults()
 
     # TODO: johbo: What we really want is to checkpoint before a test run and
     # reset the session afterwards.
     @pytest.fixture(scope='class', autouse=True)
     def cleanup_settings(self, request, baseapp):
         ui_id = RhodeCodeUi.ui_id
         original_ids = [r.ui_id for r in RhodeCodeUi.query().with_entities(ui_id)]
 
         @request.addfinalizer
         def cleanup():
             RhodeCodeUi.query().filter(
                 ui_id.notin_(original_ids)).delete(False)
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestLabsSettings(object):
     def test_get_settings_page_disabled(self):
         with mock.patch.dict(
                 rhodecode.CONFIG, {'labs_settings_active': 'false'}):
 
             response = self.app.get(
                 route_path('admin_settings_labs'), status=302)
 
         assert response.location.endswith(route_path('admin_settings'))
 
     def test_get_settings_page_enabled(self):
         from rhodecode.apps.admin.views import settings
         lab_settings = [
             settings.LabSetting(
                 key='rhodecode_bool',
                 type='bool',
                 group='bool group',
                 label='bool label',
                 help='bool help'
             ),
             settings.LabSetting(
                 key='rhodecode_text',
                 type='unicode',
                 group='text group',
                 label='text label',
                 help='text help'
             ),
         ]
         with mock.patch.dict(rhodecode.CONFIG,
                              {'labs_settings_active': 'true'}):
             with mock.patch.object(settings, '_LAB_SETTINGS', lab_settings):
                 response = self.app.get(route_path('admin_settings_labs'))
 
         assert '<label>bool group:</label>' in response
         assert '<label for="rhodecode_bool">bool label</label>' in response
         assert '<p class="help-block">bool help</p>' in response
         assert 'name="rhodecode_bool" type="checkbox"' in response
 
         assert '<label>text group:</label>' in response
         assert '<label for="rhodecode_text">text label</label>' in response
         assert '<p class="help-block">text help</p>' in response
         assert 'name="rhodecode_text" size="60" type="text"' in response
 
 
 @pytest.mark.usefixtures('app')
 class TestOpenSourceLicenses(object):
 
     def test_records_are_displayed(self, autologin_user):
         sample_licenses = [
             {
                 "license": [
                     {
                         "fullName": "BSD 4-clause \"Original\" or \"Old\" License",
                         "shortName": "bsdOriginal",
                         "spdxId": "BSD-4-Clause",
                         "url": "http://spdx.org/licenses/BSD-4-Clause.html"
                     }
                 ],
                 "name": "python2.7-coverage-3.7.1"
             },
             {
                 "license": [
                     {
                         "fullName": "MIT License",
                         "shortName": "mit",
                         "spdxId": "MIT",
                         "url": "http://spdx.org/licenses/MIT.html"
                     }
                 ],
                 "name": "python2.7-bootstrapped-pip-9.0.1"
             },
         ]
         read_licenses_patch = mock.patch(
             'rhodecode.apps.admin.views.open_source_licenses.read_opensource_licenses',
             return_value=sample_licenses)
         with read_licenses_patch:
             response = self.app.get(
                 route_path('admin_settings_open_source'), status=200)
 
         assert_response = response.assert_response()
         assert_response.element_contains(
             '.panel-heading', 'Licenses of Third Party Packages')
         for license_data in sample_licenses:
             response.mustcontain(license_data["license"][0]["spdxId"])
             assert_response.element_contains('.panel-body', license_data["name"])
 
     def test_records_can_be_read(self, autologin_user):
         response = self.app.get(
             route_path('admin_settings_open_source'), status=200)
         assert_response = response.assert_response()
         assert_response.element_contains(
             '.panel-heading', 'Licenses of Third Party Packages')
 
     def test_forbidden_when_normal_user(self, autologin_regular_user):
         self.app.get(
             route_path('admin_settings_open_source'), status=404)
 
 
 @pytest.mark.usefixtures('app')
 class TestUserSessions(object):
 
     def test_forbidden_when_normal_user(self, autologin_regular_user):
         self.app.get(route_path('admin_settings_sessions'), status=404)
 
     def test_show_sessions_page(self, autologin_user):
         response = self.app.get(route_path('admin_settings_sessions'), status=200)
         response.mustcontain('file')
 
     def test_cleanup_old_sessions(self, autologin_user, csrf_token):
 
         post_data = {
             'csrf_token': csrf_token,
             'expire_days': '60'
         }
         response = self.app.post(
             route_path('admin_settings_sessions_cleanup'), params=post_data,
             status=302)
         assert_session_flash(response, 'Cleaned up old sessions')
 
 
 @pytest.mark.usefixtures('app')
 class TestAdminSystemInfo(object):
 
     def test_forbidden_when_normal_user(self, autologin_regular_user):
         self.app.get(route_path('admin_settings_system'), status=404)
 
     def test_system_info_page(self, autologin_user):
         response = self.app.get(route_path('admin_settings_system'))
         response.mustcontain('RhodeCode Community Edition, version {}'.format(
             rhodecode.__version__))
 
     def test_system_update_new_version(self, autologin_user):
         update_data = {
             'versions': [
                 {
                     'version': '100.3.1415926535',
                     'general': 'The latest version we are ever going to ship'
                 },
                 {
                     'version': '0.0.0',
                     'general': 'The first version we ever shipped'
                 }
             ]
         }
         with mock.patch(UPDATE_DATA_QUALNAME, return_value=update_data):
             response = self.app.get(route_path('admin_settings_system_update'))
             response.mustcontain('A <b>new version</b> is available')
 
     def test_system_update_nothing_new(self, autologin_user):
         update_data = {
             'versions': [
                 {
                     'version': '0.0.0',
                     'general': 'The first version we ever shipped'
                 }
             ]
         }
         with mock.patch(UPDATE_DATA_QUALNAME, return_value=update_data):
             response = self.app.get(route_path('admin_settings_system_update'))
             response.mustcontain(
                 'This instance is already running the <b>latest</b> stable version')
 
     def test_system_update_bad_response(self, autologin_user):
         with mock.patch(UPDATE_DATA_QUALNAME, side_effect=ValueError('foo')):
             response = self.app.get(route_path('admin_settings_system_update'))
             response.mustcontain(
                 'Bad data sent from update server')
 
 
 @pytest.mark.usefixtures("app")
 class TestAdminSettingsIssueTracker(object):
     RC_PREFIX = 'rhodecode_'
     SHORT_PATTERN_KEY = 'issuetracker_pat_'
     PATTERN_KEY = RC_PREFIX + SHORT_PATTERN_KEY
     DESC_KEY = RC_PREFIX + 'issuetracker_desc_'
 
     def test_issuetracker_index(self, autologin_user):
         response = self.app.get(route_path('admin_settings_issuetracker'))
         assert response.status_code == 200
 
     def test_add_empty_issuetracker_pattern(
             self, request, autologin_user, csrf_token):
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
 
     def test_add_issuetracker_pattern(
             self, request, autologin_user, csrf_token):
         pattern = 'issuetracker_pat'
         another_pattern = pattern+'1'
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'http://url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
             'new_pattern_pattern_1': another_pattern,
             'new_pattern_url_1': 'https://url1',
             'new_pattern_prefix_1': 'prefix1',
             'new_pattern_description_1': 'description1',
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         settings = SettingsModel().get_all_settings()
         self.uid = md5_safe(pattern)
         assert settings[self.PATTERN_KEY+self.uid] == pattern
         self.another_uid = md5_safe(another_pattern)
         assert settings[self.PATTERN_KEY+self.another_uid] == another_pattern
 
         @request.addfinalizer
         def cleanup():
             defaults = SettingsModel().get_all_settings()
 
             entries = [name for name in defaults if (
                 (self.uid in name) or (self.another_uid in name))]
             start = len(self.RC_PREFIX)
             for del_key in entries:
                 # TODO: anderson: get_by_name needs name without prefix
                 entry = SettingsModel().get_setting_by_name(del_key[start:])
                 Session().delete(entry)
 
             Session().commit()
 
     def test_edit_issuetracker_pattern(
             self, autologin_user, backend, csrf_token, request):
 
         old_pattern = 'issuetracker_pat1'
         old_uid = md5_safe(old_pattern)
 
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_0': old_pattern,
             'new_pattern_url_0': 'http://url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
 
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
 
         new_pattern = 'issuetracker_pat1_edited'
         self.new_uid = md5_safe(new_pattern)
 
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_{}'.format(old_uid): new_pattern,
             'new_pattern_url_{}'.format(old_uid): 'https://url_edited',
             'new_pattern_prefix_{}'.format(old_uid): 'prefix_edited',
             'new_pattern_description_{}'.format(old_uid): 'description_edited',
             'uid': old_uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
 
         settings = SettingsModel().get_all_settings()
         assert settings[self.PATTERN_KEY+self.new_uid] == new_pattern
         assert settings[self.DESC_KEY + self.new_uid] == 'description_edited'
         assert self.PATTERN_KEY+old_uid not in settings
 
         @request.addfinalizer
         def cleanup():
             IssueTrackerSettingsModel().delete_entries(old_uid)
             IssueTrackerSettingsModel().delete_entries(self.new_uid)
 
     def test_replace_issuetracker_pattern_description(
             self, autologin_user, csrf_token, request, settings_util):
         prefix = 'issuetracker'
         pattern = 'issuetracker_pat'
         self.uid = md5_safe(pattern)
         pattern_key = '_'.join([prefix, 'pat', self.uid])
         rc_pattern_key = '_'.join(['rhodecode', pattern_key])
         desc_key = '_'.join([prefix, 'desc', self.uid])
         rc_desc_key = '_'.join(['rhodecode', desc_key])
         new_description = 'new_description'
 
         settings_util.create_rhodecode_setting(
             pattern_key, pattern, 'unicode', cleanup=False)
         settings_util.create_rhodecode_setting(
             desc_key, 'old description', 'unicode', cleanup=False)
 
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'https://url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': new_description,
             'uid': self.uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         settings = SettingsModel().get_all_settings()
         assert settings[rc_pattern_key] == pattern
         assert settings[rc_desc_key] == new_description
 
         @request.addfinalizer
         def cleanup():
             IssueTrackerSettingsModel().delete_entries(self.uid)
 
     def test_delete_issuetracker_pattern(
             self, autologin_user, backend, csrf_token, settings_util, xhr_header):
 
         old_pattern = 'issuetracker_pat_deleted'
         old_uid = md5_safe(old_pattern)
 
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_0': old_pattern,
             'new_pattern_url_0': 'http://url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
 
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
 
         post_url = route_path('admin_settings_issuetracker_delete')
         post_data = {
             'uid': old_uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, extra_environ=xhr_header, status=200)
         settings = SettingsModel().get_all_settings()
         assert self.PATTERN_KEY+old_uid not in settings
         assert self.DESC_KEY + old_uid not in settings

rhodecode/apps/admin/tests/test_admin_user_groups.py

@@ -1,171 +1,152 b''
 
 # 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 UserGroup, User
 from rhodecode.model.meta import Session
 
 from rhodecode.tests import (
-    TestController, TEST_USER_REGULAR_LOGIN, assert_session_flash)
+    TestController, assert_session_flash)
 from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'user_groups': ADMIN_PREFIX + '/user_groups',
-        'user_groups_data': ADMIN_PREFIX + '/user_groups_data',
-        'user_group_members_data': ADMIN_PREFIX + '/user_groups/{user_group_id}/members',
-        'user_groups_new': ADMIN_PREFIX + '/user_groups/new',
-        'user_groups_create': ADMIN_PREFIX + '/user_groups/create',
-        'edit_user_group': ADMIN_PREFIX + '/user_groups/{user_group_id}/edit',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 class TestAdminUserGroupsView(TestController):
 
     def test_show_users(self):
         self.log_user()
         self.app.get(route_path('user_groups'))
 
     def test_show_user_groups_data(self, xhr_header):
         self.log_user()
         response = self.app.get(route_path(
             'user_groups_data'), extra_environ=xhr_header)
 
         all_user_groups = UserGroup.query().count()
         assert response.json['recordsTotal'] == all_user_groups
 
     def test_show_user_groups_data_filtered(self, xhr_header):
         self.log_user()
         response = self.app.get(route_path(
             'user_groups_data', params={'search[value]': 'empty_search'}),
             extra_environ=xhr_header)
 
         all_user_groups = UserGroup.query().count()
         assert response.json['recordsTotal'] == all_user_groups
         assert response.json['recordsFiltered'] == 0
 
     def test_usergroup_escape(self, user_util, xhr_header):
         self.log_user()
 
         xss_img = '<img src="/image1" onload="alert(\'Hello, World!\');">'
         user = user_util.create_user()
         user.name = xss_img
         user.lastname = xss_img
         Session().add(user)
         Session().commit()
 
         user_group = user_util.create_user_group()
 
         user_group.users_group_name = xss_img
         user_group.user_group_description = '<strong onload="alert();">DESC</strong>'
 
         response = self.app.get(
             route_path('user_groups_data'), extra_environ=xhr_header)
 
         response.mustcontain(
             '&lt;strong onload=&#34;alert();&#34;&gt;DESC&lt;/strong&gt;')
         response.mustcontain(
             '&lt;img src=&#34;/image1&#34; onload=&#34;'
             'alert(&#39;Hello, World!&#39;);&#34;&gt;')
 
     def test_edit_user_group_autocomplete_empty_members(self, xhr_header, user_util):
         self.log_user()
         ug = user_util.create_user_group()
         response = self.app.get(
             route_path('user_group_members_data', user_group_id=ug.users_group_id),
             extra_environ=xhr_header)
 
         assert response.json == {'members': []}
 
     def test_edit_user_group_autocomplete_members(self, xhr_header, user_util):
         self.log_user()
         members = [u.user_id for u in User.get_all()]
         ug = user_util.create_user_group(members=members)
         response = self.app.get(
             route_path('user_group_members_data',
                        user_group_id=ug.users_group_id),
             extra_environ=xhr_header)
 
         assert len(response.json['members']) == len(members)
 
     def test_creation_page(self):
         self.log_user()
         self.app.get(route_path('user_groups_new'), status=200)
 
     def test_create(self):
         from rhodecode.lib import helpers as h
 
         self.log_user()
         users_group_name = 'test_user_group'
         response = self.app.post(route_path('user_groups_create'), {
             'users_group_name': users_group_name,
             'user_group_description': 'DESC',
             'active': True,
             'csrf_token': self.csrf_token})
 
         user_group_id = UserGroup.get_by_group_name(
             users_group_name).users_group_id
 
         user_group_link = h.link_to(
             users_group_name,
             route_path('edit_user_group', user_group_id=user_group_id))
 
         assert_session_flash(
             response,
             'Created user group %s' % user_group_link)
 
         fixture.destroy_user_group(users_group_name)
 
     def test_create_with_empty_name(self):
         self.log_user()
 
         response = self.app.post(route_path('user_groups_create'), {
             'users_group_name': '',
             'user_group_description': 'DESC',
             'active': True,
             'csrf_token': self.csrf_token}, status=200)
 
         response.mustcontain('Please enter a value')
 
     def test_create_duplicate(self, user_util):
         self.log_user()
 
         user_group = user_util.create_user_group()
         duplicate_name = user_group.users_group_name
         response = self.app.post(route_path('user_groups_create'), {
             'users_group_name': duplicate_name,
             'user_group_description': 'DESC',
             'active': True,
             'csrf_token': self.csrf_token}, status=200)
 
         response.mustcontain(
             'User group `{}` already exists'.format(duplicate_name))

rhodecode/apps/admin/tests/test_admin_users.py

@@ -1,795 +1,727 b''
 
 # 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 sqlalchemy.orm.exc import NoResultFound
 
 from rhodecode.lib import auth
 from rhodecode.lib import helpers as h
 from rhodecode.model.db import User, UserApiKeys, UserEmailMap, Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.user import UserModel
 
 from rhodecode.tests import (
     TestController, TEST_USER_REGULAR_LOGIN, assert_session_flash)
 from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'users':
-            ADMIN_PREFIX + '/users',
-        'users_data':
-            ADMIN_PREFIX + '/users_data',
-        'users_create':
-            ADMIN_PREFIX + '/users/create',
-        'users_new':
-            ADMIN_PREFIX + '/users/new',
-        'user_edit':
-            ADMIN_PREFIX + '/users/{user_id}/edit',
-        'user_edit_advanced':
-            ADMIN_PREFIX + '/users/{user_id}/edit/advanced',
-        'user_edit_global_perms':
-            ADMIN_PREFIX + '/users/{user_id}/edit/global_permissions',
-        'user_edit_global_perms_update':
-            ADMIN_PREFIX + '/users/{user_id}/edit/global_permissions/update',
-        'user_update':
-            ADMIN_PREFIX + '/users/{user_id}/update',
-        'user_delete':
-            ADMIN_PREFIX + '/users/{user_id}/delete',
-        'user_create_personal_repo_group':
-            ADMIN_PREFIX + '/users/{user_id}/create_repo_group',
-
-        'edit_user_auth_tokens':
-            ADMIN_PREFIX + '/users/{user_id}/edit/auth_tokens',
-        'edit_user_auth_tokens_add':
-            ADMIN_PREFIX + '/users/{user_id}/edit/auth_tokens/new',
-        'edit_user_auth_tokens_delete':
-            ADMIN_PREFIX + '/users/{user_id}/edit/auth_tokens/delete',
-
-        'edit_user_emails':
-            ADMIN_PREFIX + '/users/{user_id}/edit/emails',
-        'edit_user_emails_add':
-            ADMIN_PREFIX + '/users/{user_id}/edit/emails/new',
-        'edit_user_emails_delete':
-            ADMIN_PREFIX + '/users/{user_id}/edit/emails/delete',
-
-        'edit_user_ips':
-            ADMIN_PREFIX + '/users/{user_id}/edit/ips',
-        'edit_user_ips_add':
-            ADMIN_PREFIX + '/users/{user_id}/edit/ips/new',
-        'edit_user_ips_delete':
-            ADMIN_PREFIX + '/users/{user_id}/edit/ips/delete',
-
-        'edit_user_perms_summary':
-            ADMIN_PREFIX + '/users/{user_id}/edit/permissions_summary',
-        'edit_user_perms_summary_json':
-            ADMIN_PREFIX + '/users/{user_id}/edit/permissions_summary/json',
-
-        'edit_user_audit_logs':
-            ADMIN_PREFIX + '/users/{user_id}/edit/audit',
-
-        'edit_user_audit_logs_download':
-            ADMIN_PREFIX + '/users/{user_id}/edit/audit/download',
-
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 class TestAdminUsersView(TestController):
 
     def test_show_users(self):
         self.log_user()
         self.app.get(route_path('users'))
 
     def test_show_users_data(self, xhr_header):
         self.log_user()
         response = self.app.get(route_path(
             'users_data'), extra_environ=xhr_header)
 
         all_users = User.query().filter(
             User.username != User.DEFAULT_USER).count()
         assert response.json['recordsTotal'] == all_users
 
     def test_show_users_data_filtered(self, xhr_header):
         self.log_user()
         response = self.app.get(route_path(
             'users_data', params={'search[value]': 'empty_search'}),
             extra_environ=xhr_header)
 
         all_users = User.query().filter(
             User.username != User.DEFAULT_USER).count()
         assert response.json['recordsTotal'] == all_users
         assert response.json['recordsFiltered'] == 0
 
     def test_auth_tokens_default_user(self):
         self.log_user()
         user = User.get_default_user()
         response = self.app.get(
             route_path('edit_user_auth_tokens', user_id=user.user_id),
             status=302)
 
     def test_auth_tokens(self):
         self.log_user()
 
         user = User.get_by_username(TEST_USER_REGULAR_LOGIN)
         user_id = user.user_id
         auth_tokens = user.auth_tokens
         response = self.app.get(
             route_path('edit_user_auth_tokens', user_id=user_id))
         for token in auth_tokens:
             response.mustcontain(token[:4])
             response.mustcontain('never')
 
     @pytest.mark.parametrize("desc, lifetime", [
         ('forever', -1),
         ('5mins', 60*5),
         ('30days', 60*60*24*30),
     ])
     def test_add_auth_token(self, desc, lifetime, user_util):
         self.log_user()
         user = user_util.create_user()
         user_id = user.user_id
 
         response = self.app.post(
             route_path('edit_user_auth_tokens_add', user_id=user_id),
             {'description': desc, 'lifetime': lifetime,
              'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Auth token successfully created')
 
         response = response.follow()
         user = User.get(user_id)
         for auth_token in user.auth_tokens:
             response.mustcontain(auth_token[:4])
 
     def test_delete_auth_token(self, user_util):
         self.log_user()
         user = user_util.create_user()
         user_id = user.user_id
         keys = user.auth_tokens
         assert 2 == len(keys)
 
         response = self.app.post(
             route_path('edit_user_auth_tokens_add', user_id=user_id),
             {'description': 'desc', 'lifetime': -1,
              'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Auth token successfully created')
         response.follow()
 
         # now delete our key
         keys = UserApiKeys.query().filter(UserApiKeys.user_id == user_id).all()
         assert 3 == len(keys)
 
         response = self.app.post(
             route_path('edit_user_auth_tokens_delete', user_id=user_id),
             {'del_auth_token': keys[0].user_api_key_id,
              'csrf_token': self.csrf_token})
 
         assert_session_flash(response, 'Auth token successfully deleted')
         keys = UserApiKeys.query().filter(UserApiKeys.user_id == user_id).all()
         assert 2 == len(keys)
 
     def test_ips(self):
         self.log_user()
         user = User.get_by_username(TEST_USER_REGULAR_LOGIN)
         response = self.app.get(route_path('edit_user_ips', user_id=user.user_id))
         response.mustcontain('All IP addresses are allowed')
 
     @pytest.mark.parametrize("test_name, ip, ip_range, failure", [
         ('127/24', '127.0.0.1/24', '127.0.0.0 - 127.0.0.255', False),
         ('10/32', '10.0.0.10/32', '10.0.0.10 - 10.0.0.10', False),
         ('0/16', '0.0.0.0/16', '0.0.0.0 - 0.0.255.255', False),
         ('0/8', '0.0.0.0/8', '0.0.0.0 - 0.255.255.255', False),
         ('127_bad_mask', '127.0.0.1/99', '127.0.0.1 - 127.0.0.1', True),
         ('127_bad_ip', 'foobar', 'foobar', True),
     ])
     def test_ips_add(self, user_util, test_name, ip, ip_range, failure):
         self.log_user()
         user = user_util.create_user(username=test_name)
         user_id = user.user_id
 
         response = self.app.post(
             route_path('edit_user_ips_add', user_id=user_id),
             params={'new_ip': ip, 'csrf_token': self.csrf_token})
 
         if failure:
             assert_session_flash(
                 response, 'Please enter a valid IPv4 or IpV6 address')
             response = self.app.get(route_path('edit_user_ips', user_id=user_id))
 
             response.mustcontain(no=[ip])
             response.mustcontain(no=[ip_range])
 
         else:
             response = self.app.get(route_path('edit_user_ips', user_id=user_id))
             response.mustcontain(ip)
             response.mustcontain(ip_range)
 
     def test_ips_delete(self, user_util):
         self.log_user()
         user = user_util.create_user()
         user_id = user.user_id
         ip = '127.0.0.1/32'
         ip_range = '127.0.0.1 - 127.0.0.1'
         new_ip = UserModel().add_extra_ip(user_id, ip)
         Session().commit()
         new_ip_id = new_ip.ip_id
 
         response = self.app.get(route_path('edit_user_ips', user_id=user_id))
         response.mustcontain(ip)
         response.mustcontain(ip_range)
 
         self.app.post(
             route_path('edit_user_ips_delete', user_id=user_id),
             params={'del_ip_id': new_ip_id, 'csrf_token': self.csrf_token})
 
         response = self.app.get(route_path('edit_user_ips', user_id=user_id))
         response.mustcontain('All IP addresses are allowed')
         response.mustcontain(no=[ip])
         response.mustcontain(no=[ip_range])
 
     def test_emails(self):
         self.log_user()
         user = User.get_by_username(TEST_USER_REGULAR_LOGIN)
         response = self.app.get(
             route_path('edit_user_emails', user_id=user.user_id))
         response.mustcontain('No additional emails specified')
 
     def test_emails_add(self, user_util):
         self.log_user()
         user = user_util.create_user()
         user_id = user.user_id
 
         self.app.post(
             route_path('edit_user_emails_add', user_id=user_id),
             params={'new_email': '[e-mail]',
                     'csrf_token': self.csrf_token})
 
         response = self.app.get(
             route_path('edit_user_emails', user_id=user_id))
         response.mustcontain('[e-mail]')
 
     def test_emails_add_existing_email(self, user_util, user_regular):
         existing_email = user_regular.email
 
         self.log_user()
         user = user_util.create_user()
         user_id = user.user_id
 
         response = self.app.post(
             route_path('edit_user_emails_add', user_id=user_id),
             params={'new_email': existing_email,
                     'csrf_token': self.csrf_token})
         assert_session_flash(
             response, 'This e-mail address is already taken')
 
         response = self.app.get(
             route_path('edit_user_emails', user_id=user_id))
         response.mustcontain(no=[existing_email])
 
     def test_emails_delete(self, user_util):
         self.log_user()
         user = user_util.create_user()
         user_id = user.user_id
 
         self.app.post(
             route_path('edit_user_emails_add', user_id=user_id),
             params={'new_email': '[e-mail]',
                     'csrf_token': self.csrf_token})
 
         response = self.app.get(
             route_path('edit_user_emails', user_id=user_id))
         response.mustcontain('[e-mail]')
 
         user_email = UserEmailMap.query()\
             .filter(UserEmailMap.email == '[e-mail]') \
             .filter(UserEmailMap.user_id == user_id)\
             .one()
 
         del_email_id = user_email.email_id
         self.app.post(
             route_path('edit_user_emails_delete', user_id=user_id),
             params={'del_email_id': del_email_id,
                     'csrf_token': self.csrf_token})
 
         response = self.app.get(
             route_path('edit_user_emails', user_id=user_id))
         response.mustcontain(no=['[e-mail]'])
 
     def test_create(self, request, xhr_header):
         self.log_user()
         username = 'newtestuser'
         password = 'test12'
         password_confirmation = password
         name = 'name'
         lastname = 'lastname'
         email = '[e-mail]'
 
         self.app.get(route_path('users_new'))
 
         response = self.app.post(route_path('users_create'), params={
             'username': username,
             'password': password,
             'description': 'mr CTO',
             'password_confirmation': password_confirmation,
             'firstname': name,
             'active': True,
             'lastname': lastname,
             'extern_name': 'rhodecode',
             'extern_type': 'rhodecode',
             'email': email,
             'csrf_token': self.csrf_token,
         })
         user_link = h.link_to(
             username,
             route_path(
                 'user_edit', user_id=User.get_by_username(username).user_id))
         assert_session_flash(response, 'Created user %s' % (user_link,))
 
         @request.addfinalizer
         def cleanup():
             fixture.destroy_user(username)
             Session().commit()
 
         new_user = User.query().filter(User.username == username).one()
 
         assert new_user.username == username
         assert auth.check_password(password, new_user.password)
         assert new_user.name == name
         assert new_user.lastname == lastname
         assert new_user.email == email
 
         response = self.app.get(route_path('users_data'),
                                 extra_environ=xhr_header)
         response.mustcontain(username)
 
     def test_create_err(self):
         self.log_user()
         username = 'new_user'
         password = ''
         name = 'name'
         lastname = 'lastname'
         email = 'errmail.com'
 
         self.app.get(route_path('users_new'))
 
         response = self.app.post(route_path('users_create'), params={
             'username': username,
             'password': password,
             'name': name,
             'active': False,
             'lastname': lastname,
             'description': 'mr CTO',
             'email': email,
             'csrf_token': self.csrf_token,
         })
 
         msg = u'Username "%(username)s" is forbidden'
         msg = h.html_escape(msg % {'username': 'new_user'})
         response.mustcontain('<span class="error-message">%s</span>' % msg)
         response.mustcontain(
             '<span class="error-message">Please enter a value</span>')
         response.mustcontain(
             '<span class="error-message">An email address must contain a'
             ' single @</span>')
 
         def get_user():
             Session().query(User).filter(User.username == username).one()
 
         with pytest.raises(NoResultFound):
             get_user()
 
     def test_new(self):
         self.log_user()
         self.app.get(route_path('users_new'))
 
     @pytest.mark.parametrize("name, attrs", [
         ('firstname', {'firstname': 'new_username'}),
         ('lastname', {'lastname': 'new_username'}),
         ('admin', {'admin': True}),
         ('admin', {'admin': False}),
         ('extern_type', {'extern_type': 'ldap'}),
         ('extern_type', {'extern_type': None}),
         ('extern_name', {'extern_name': 'test'}),
         ('extern_name', {'extern_name': None}),
         ('active', {'active': False}),
         ('active', {'active': True}),
         ('email', {'email': '[e-mail]'}),
         ('language', {'language': 'de'}),
         ('language', {'language': 'en'}),
         ('description', {'description': 'hello CTO'}),
         # ('new_password', {'new_password': 'foobar123',
         #                   'password_confirmation': 'foobar123'})
         ])
     def test_update(self, name, attrs, user_util):
         self.log_user()
         usr = user_util.create_user(
             password='qweqwe',
             email='[e-mail]',
             extern_type='rhodecode',
             extern_name='xxx',
         )
         user_id = usr.user_id
         Session().commit()
 
         params = usr.get_api_data()
         cur_lang = params['language'] or 'en'
         params.update({
             'password_confirmation': '',
             'new_password': '',
             'language': cur_lang,
             'csrf_token': self.csrf_token,
         })
         params.update({'new_password': ''})
         params.update(attrs)
         if name == 'email':
             params['emails'] = [attrs['email']]
         elif name == 'extern_type':
             # cannot update this via form, expected value is original one
             params['extern_type'] = "rhodecode"
         elif name == 'extern_name':
             # cannot update this via form, expected value is original one
             params['extern_name'] = 'xxx'
             # special case since this user is not
             # logged in yet his data is not filled
             # so we use creation data
 
         response = self.app.post(
             route_path('user_update', user_id=usr.user_id), params)
         assert response.status_int == 302
         assert_session_flash(response, 'User updated successfully')
 
         updated_user = User.get(user_id)
         updated_params = updated_user.get_api_data()
         updated_params.update({'password_confirmation': ''})
         updated_params.update({'new_password': ''})
 
         del params['csrf_token']
         assert params == updated_params
 
     def test_update_and_migrate_password(
             self, autologin_user, real_crypto_backend, user_util):
 
         user = user_util.create_user()
         temp_user = user.username
         user.password = auth._RhodeCodeCryptoSha256().hash_create(
             b'test123')
         Session().add(user)
         Session().commit()
 
         params = user.get_api_data()
 
         params.update({
             'password_confirmation': 'qweqwe123',
             'new_password': 'qweqwe123',
             'language': 'en',
             'csrf_token': autologin_user.csrf_token,
         })
 
         response = self.app.post(
             route_path('user_update', user_id=user.user_id), params)
         assert response.status_int == 302
         assert_session_flash(response, 'User updated successfully')
 
         # new password should be bcrypted, after log-in and transfer
         user = User.get_by_username(temp_user)
         assert user.password.startswith('$')
 
         updated_user = User.get_by_username(temp_user)
         updated_params = updated_user.get_api_data()
         updated_params.update({'password_confirmation': 'qweqwe123'})
         updated_params.update({'new_password': 'qweqwe123'})
 
         del params['csrf_token']
         assert params == updated_params
 
     def test_delete(self):
         self.log_user()
         username = 'newtestuserdeleteme'
 
         fixture.create_user(name=username)
 
         new_user = Session().query(User)\
             .filter(User.username == username).one()
         response = self.app.post(
             route_path('user_delete', user_id=new_user.user_id),
             params={'csrf_token': self.csrf_token})
 
         assert_session_flash(response, 'Successfully deleted user `{}`'.format(username))
 
     def test_delete_owner_of_repository(self, request, user_util):
         self.log_user()
         obj_name = 'test_repo'
         usr = user_util.create_user()
         username = usr.username
         fixture.create_repo(obj_name, cur_user=usr.username)
 
         new_user = Session().query(User)\
             .filter(User.username == username).one()
         response = self.app.post(
             route_path('user_delete', user_id=new_user.user_id),
             params={'csrf_token': self.csrf_token})
 
         msg = 'user "%s" still owns 1 repositories and cannot be removed. ' \
               'Switch owners or remove those repositories:%s' % (username, obj_name)
         assert_session_flash(response, msg)
         fixture.destroy_repo(obj_name)
 
     def test_delete_owner_of_repository_detaching(self, request, user_util):
         self.log_user()
         obj_name = 'test_repo'
         usr = user_util.create_user(auto_cleanup=False)
         username = usr.username
         fixture.create_repo(obj_name, cur_user=usr.username)
         Session().commit()
 
         new_user = Session().query(User)\
             .filter(User.username == username).one()
         response = self.app.post(
             route_path('user_delete', user_id=new_user.user_id),
             params={'user_repos': 'detach', 'csrf_token': self.csrf_token})
 
         msg = 'Detached 1 repositories'
         assert_session_flash(response, msg)
         fixture.destroy_repo(obj_name)
 
     def test_delete_owner_of_repository_deleting(self, request, user_util):
         self.log_user()
         obj_name = 'test_repo'
         usr = user_util.create_user(auto_cleanup=False)
         username = usr.username
         fixture.create_repo(obj_name, cur_user=usr.username)
 
         new_user = Session().query(User)\
             .filter(User.username == username).one()
         response = self.app.post(
             route_path('user_delete', user_id=new_user.user_id),
             params={'user_repos': 'delete', 'csrf_token': self.csrf_token})
 
         msg = 'Deleted 1 repositories'
         assert_session_flash(response, msg)
 
     def test_delete_owner_of_repository_group(self, request, user_util):
         self.log_user()
         obj_name = 'test_group'
         usr = user_util.create_user()
         username = usr.username
         fixture.create_repo_group(obj_name, cur_user=usr.username)
 
         new_user = Session().query(User)\
             .filter(User.username == username).one()
         response = self.app.post(
             route_path('user_delete', user_id=new_user.user_id),
             params={'csrf_token': self.csrf_token})
 
         msg = 'user "%s" still owns 1 repository groups and cannot be removed. ' \
               'Switch owners or remove those repository groups:%s' % (username, obj_name)
         assert_session_flash(response, msg)
         fixture.destroy_repo_group(obj_name)
 
     def test_delete_owner_of_repository_group_detaching(self, request, user_util):
         self.log_user()
         obj_name = 'test_group'
         usr = user_util.create_user(auto_cleanup=False)
         username = usr.username
         fixture.create_repo_group(obj_name, cur_user=usr.username)
 
         new_user = Session().query(User)\
             .filter(User.username == username).one()
         response = self.app.post(
             route_path('user_delete', user_id=new_user.user_id),
             params={'user_repo_groups': 'delete', 'csrf_token': self.csrf_token})
 
         msg = 'Deleted 1 repository groups'
         assert_session_flash(response, msg)
 
     def test_delete_owner_of_repository_group_deleting(self, request, user_util):
         self.log_user()
         obj_name = 'test_group'
         usr = user_util.create_user(auto_cleanup=False)
         username = usr.username
         fixture.create_repo_group(obj_name, cur_user=usr.username)
 
         new_user = Session().query(User)\
             .filter(User.username == username).one()
         response = self.app.post(
             route_path('user_delete', user_id=new_user.user_id),
             params={'user_repo_groups': 'detach', 'csrf_token': self.csrf_token})
 
         msg = 'Detached 1 repository groups'
         assert_session_flash(response, msg)
         fixture.destroy_repo_group(obj_name)
 
     def test_delete_owner_of_user_group(self, request, user_util):
         self.log_user()
         obj_name = 'test_user_group'
         usr = user_util.create_user()
         username = usr.username
         fixture.create_user_group(obj_name, cur_user=usr.username)
 
         new_user = Session().query(User)\
             .filter(User.username == username).one()
         response = self.app.post(
             route_path('user_delete', user_id=new_user.user_id),
             params={'csrf_token': self.csrf_token})
 
         msg = 'user "%s" still owns 1 user groups and cannot be removed. ' \
               'Switch owners or remove those user groups:%s' % (username, obj_name)
         assert_session_flash(response, msg)
         fixture.destroy_user_group(obj_name)
 
     def test_delete_owner_of_user_group_detaching(self, request, user_util):
         self.log_user()
         obj_name = 'test_user_group'
         usr = user_util.create_user(auto_cleanup=False)
         username = usr.username
         fixture.create_user_group(obj_name, cur_user=usr.username)
 
         new_user = Session().query(User)\
             .filter(User.username == username).one()
         try:
             response = self.app.post(
                 route_path('user_delete', user_id=new_user.user_id),
                 params={'user_user_groups': 'detach',
                         'csrf_token': self.csrf_token})
 
             msg = 'Detached 1 user groups'
             assert_session_flash(response, msg)
         finally:
             fixture.destroy_user_group(obj_name)
 
     def test_delete_owner_of_user_group_deleting(self, request, user_util):
         self.log_user()
         obj_name = 'test_user_group'
         usr = user_util.create_user(auto_cleanup=False)
         username = usr.username
         fixture.create_user_group(obj_name, cur_user=usr.username)
 
         new_user = Session().query(User)\
             .filter(User.username == username).one()
         response = self.app.post(
             route_path('user_delete', user_id=new_user.user_id),
             params={'user_user_groups': 'delete', 'csrf_token': self.csrf_token})
 
         msg = 'Deleted 1 user groups'
         assert_session_flash(response, msg)
 
     def test_edit(self, user_util):
         self.log_user()
         user = user_util.create_user()
         self.app.get(route_path('user_edit', user_id=user.user_id))
 
     def test_edit_default_user_redirect(self):
         self.log_user()
         user = User.get_default_user()
         self.app.get(route_path('user_edit', user_id=user.user_id), status=302)
 
     @pytest.mark.parametrize(
         'repo_create, repo_create_write, user_group_create, repo_group_create,'
         'fork_create, inherit_default_permissions, expect_error,'
         'expect_form_error', [
             ('hg.create.none', 'hg.create.write_on_repogroup.false',
              'hg.usergroup.create.false', 'hg.repogroup.create.false',
              'hg.fork.none', 'hg.inherit_default_perms.false', False, False),
             ('hg.create.repository', 'hg.create.write_on_repogroup.false',
              'hg.usergroup.create.false', 'hg.repogroup.create.false',
              'hg.fork.none', 'hg.inherit_default_perms.false', False, False),
             ('hg.create.repository', 'hg.create.write_on_repogroup.true',
              'hg.usergroup.create.true', 'hg.repogroup.create.true',
              'hg.fork.repository', 'hg.inherit_default_perms.false', False,
              False),
             ('hg.create.XXX', 'hg.create.write_on_repogroup.true',
              'hg.usergroup.create.true', 'hg.repogroup.create.true',
              'hg.fork.repository', 'hg.inherit_default_perms.false', False,
              True),
             ('', '', '', '', '', '', True, False),
         ])
     def test_global_perms_on_user(
             self, repo_create, repo_create_write, user_group_create,
             repo_group_create, fork_create, expect_error, expect_form_error,
             inherit_default_permissions, user_util):
         self.log_user()
         user = user_util.create_user()
         uid = user.user_id
 
         # ENABLE REPO CREATE ON A GROUP
         perm_params = {
             'inherit_default_permissions': False,
             'default_repo_create': repo_create,
             'default_repo_create_on_write': repo_create_write,
             'default_user_group_create': user_group_create,
             'default_repo_group_create': repo_group_create,
             'default_fork_create': fork_create,
             'default_inherit_default_permissions': inherit_default_permissions,
             'csrf_token': self.csrf_token,
         }
         response = self.app.post(
             route_path('user_edit_global_perms_update', user_id=uid),
             params=perm_params)
 
         if expect_form_error:
             assert response.status_int == 200
             response.mustcontain('Value must be one of')
         else:
             if expect_error:
                 msg = 'An error occurred during permissions saving'
             else:
                 msg = 'User global permissions updated successfully'
                 ug = User.get(uid)
                 del perm_params['inherit_default_permissions']
                 del perm_params['csrf_token']
                 assert perm_params == ug.get_default_perms()
             assert_session_flash(response, msg)
 
     def test_global_permissions_initial_values(self, user_util):
         self.log_user()
         user = user_util.create_user()
         uid = user.user_id
         response = self.app.get(
             route_path('user_edit_global_perms', user_id=uid))
         default_user = User.get_default_user()
         default_permissions = default_user.get_default_perms()
         assert_response = response.assert_response()
         expected_permissions = (
             'default_repo_create', 'default_repo_create_on_write',
             'default_fork_create', 'default_repo_group_create',
             'default_user_group_create', 'default_inherit_default_permissions')
         for permission in expected_permissions:
             css_selector = '[name={}][checked=checked]'.format(permission)
             element = assert_response.get_element(css_selector)
             assert element.value == default_permissions[permission]
 
     def test_perms_summary_page(self):
         user = self.log_user()
         response = self.app.get(
             route_path('edit_user_perms_summary', user_id=user['user_id']))
         for repo in Repository.query().all():
             response.mustcontain(repo.repo_name)
 
     def test_perms_summary_page_json(self):
         user = self.log_user()
         response = self.app.get(
             route_path('edit_user_perms_summary_json', user_id=user['user_id']))
         for repo in Repository.query().all():
             response.mustcontain(repo.repo_name)
 
     def test_audit_log_page(self):
         user = self.log_user()
         self.app.get(
             route_path('edit_user_audit_logs', user_id=user['user_id']))
 
     def test_audit_log_page_download(self):
         user = self.log_user()
         user_id = user['user_id']
         response = self.app.get(
             route_path('edit_user_audit_logs_download', user_id=user_id))
 
         assert response.content_disposition == \
                'attachment; filename=user_{}_audit_logs.json'.format(user_id)
         assert response.content_type == "application/json"

rhodecode/apps/admin/tests/test_admin_users_ssh_keys.py

@@ -1,177 +1,155 b''
 
 # 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, UserSshKeys
 
 from rhodecode.tests import TestController, assert_session_flash
 from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'edit_user_ssh_keys':
-            ADMIN_PREFIX + '/users/{user_id}/edit/ssh_keys',
-        'edit_user_ssh_keys_generate_keypair':
-            ADMIN_PREFIX + '/users/{user_id}/edit/ssh_keys/generate',
-        'edit_user_ssh_keys_add':
-            ADMIN_PREFIX + '/users/{user_id}/edit/ssh_keys/new',
-        'edit_user_ssh_keys_delete':
-            ADMIN_PREFIX + '/users/{user_id}/edit/ssh_keys/delete',
-
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 class TestAdminUsersSshKeysView(TestController):
     INVALID_KEY = """\
             ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDk+77sjDzVeB6vevJsuZds1iNU5
             LANOa5CU5G/9JYIA6RYsWWMO7mbsR82IUckdqOHmxSykfR1D1TdluyIpQLrwgH5kb
             n8FkVI8zBMCKakxowvN67B0R7b1BT4PPzW2JlOXei/m9W12ZY484VTow6/B+kf2Q8
             cP8tmCJmKWZma5Em7OTUhvjyQVNz3v7HfeY5Hq0Ci4ECJ59hepFDabJvtAXg9XrI6
             jvdphZTc30I4fG8+hBHzpeFxUGvSGNtXPUbwaAY8j/oHYrTpMgkj6pUEFsiKfC5zP
             qPFR5HyKTCHW0nFUJnZsbyFT5hMiF/hZkJc9A0ZbdSvJwCRQ/g3bmdL 
             [e-mail]      
         """
     VALID_KEY = 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDk+77sjDzVeB6vev' \
                    'JsuZds1iNU5LANOa5CU5G/9JYIA6RYsWWMO7mbsR82IUckdqOHmxSy' \
                    'kfR1D1TdluyIpQLrwgH5kbn8FkVI8zBMCKakxowvN67B0R7b1BT4PP' \
                    'zW2JlOXei/m9W12ZY484VTow6/B+kf2Q8cP8tmCJmKWZma5Em7OTUh' \
                    'vjyQVNz3v7HfeY5Hq0Ci4ECJ59hepFDabJvtAXg9XrI6jvdphZTc30' \
                    'I4fG8+hBHzpeFxUGvSGNtXPUbwaAY8j/oHYrTpMgkj6pUEFsiKfC5zPq' \
                    'PFR5HyKTCHW0nFUJnZsbyFT5hMiF/hZkJc9A0ZbdSvJwCRQ/g3bmdL ' \
                    '[e-mail]'
     FINGERPRINT = 'MD5:01:4f:ad:29:22:6e:01:37:c9:d2:52:26:52:b0:2d:93'
 
     def test_ssh_keys_default_user(self):
         self.log_user()
         user = User.get_default_user()
         self.app.get(
             route_path('edit_user_ssh_keys', user_id=user.user_id),
             status=302)
 
     def test_add_ssh_key_error(self, user_util):
         self.log_user()
         user = user_util.create_user()
         user_id = user.user_id
 
         key_data = self.INVALID_KEY
 
         desc = 'MY SSH KEY'
         response = self.app.post(
             route_path('edit_user_ssh_keys_add', user_id=user_id),
             {'description': desc, 'key_data': key_data,
              'csrf_token': self.csrf_token})
         assert_session_flash(response, 'An error occurred during ssh '
                                        'key saving: Unable to decode the key')
 
     def test_ssh_key_duplicate(self, user_util):
         self.log_user()
         user = user_util.create_user()
         user_id = user.user_id
 
         key_data = self.VALID_KEY
 
         desc = 'MY SSH KEY'
         response = self.app.post(
             route_path('edit_user_ssh_keys_add', user_id=user_id),
             {'description': desc, 'key_data': key_data,
              'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Ssh Key successfully created')
         response.follow()  # flush session flash
 
         # add the same key AGAIN
         desc = 'MY SSH KEY'
         response = self.app.post(
             route_path('edit_user_ssh_keys_add', user_id=user_id),
             {'description': desc, 'key_data': key_data,
              'csrf_token': self.csrf_token})
 
         err = 'Such key with fingerprint `{}` already exists, ' \
               'please use a different one'.format(self.FINGERPRINT)
         assert_session_flash(response, 'An error occurred during ssh key '
                                        'saving: {}'.format(err))
 
     def test_add_ssh_key(self, user_util):
         self.log_user()
         user = user_util.create_user()
         user_id = user.user_id
 
         key_data = self.VALID_KEY
 
         desc = 'MY SSH KEY'
         response = self.app.post(
             route_path('edit_user_ssh_keys_add', user_id=user_id),
             {'description': desc, 'key_data': key_data,
              'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Ssh Key successfully created')
 
         response = response.follow()
         response.mustcontain(desc)
 
     def test_delete_ssh_key(self, user_util):
         self.log_user()
         user = user_util.create_user()
         user_id = user.user_id
 
         key_data = self.VALID_KEY
 
         desc = 'MY SSH KEY'
         response = self.app.post(
             route_path('edit_user_ssh_keys_add', user_id=user_id),
             {'description': desc, 'key_data': key_data,
              'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Ssh Key successfully created')
         response = response.follow()  # flush the Session flash
 
         # now delete our key
         keys = UserSshKeys.query().filter(UserSshKeys.user_id == user_id).all()
         assert 1 == len(keys)
 
         response = self.app.post(
             route_path('edit_user_ssh_keys_delete', user_id=user_id),
             {'del_ssh_key': keys[0].ssh_key_id,
              'csrf_token': self.csrf_token})
 
         assert_session_flash(response, 'Ssh key successfully deleted')
         keys = UserSshKeys.query().filter(UserSshKeys.user_id == user_id).all()
         assert 0 == len(keys)
 
     def test_generate_keypair(self, user_util):
         self.log_user()
         user = user_util.create_user()
         user_id = user.user_id
 
         response = self.app.get(
             route_path('edit_user_ssh_keys_generate_keypair', user_id=user_id))
 
         response.mustcontain('Private key')
         response.mustcontain('Public key')
         response.mustcontain('-----BEGIN PRIVATE KEY-----')

rhodecode/apps/file_store/tests/test_upload_file.py

@@ -1,261 +1,246 b''
 # 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.lib.ext_json import json
 from rhodecode.model.auth_token import AuthTokenModel
 from rhodecode.model.db import Session, FileStore, Repository, User
-from rhodecode.tests import TestController
 from rhodecode.apps.file_store import utils, config_keys
 
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'upload_file': '/_file_store/upload',
-        'download_file': '/_file_store/download/{fid}',
-        'download_file_by_token': '/_file_store/token-download/{_auth_token}/{fid}'
-
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests import TestController
+from rhodecode.tests.routes import route_path
 
 
 class TestFileStoreViews(TestController):
 
     @pytest.mark.parametrize("fid, content, exists", [
         ('abcde-0.jpg', "xxxxx", True),
         ('abcde-0.exe', "1234567", True),
         ('abcde-0.jpg', "xxxxx", False),
     ])
     def test_get_files_from_store(self, fid, content, exists, tmpdir, user_util):
         user = self.log_user()
         user_id = user['user_id']
         repo_id = user_util.create_repo().repo_id
         store_path = self.app._pyramid_settings[config_keys.store_path]
         store_uid = fid
 
         if exists:
             status = 200
             store = utils.get_file_storage({config_keys.store_path: store_path})
             filesystem_file = os.path.join(str(tmpdir), fid)
             with open(filesystem_file, 'wt') as f:
                 f.write(content)
 
             with open(filesystem_file, 'rb') as f:
                 store_uid, metadata = store.save_file(f, fid, extra_metadata={'filename': fid})
 
             entry = FileStore.create(
                 file_uid=store_uid, filename=metadata["filename"],
                 file_hash=metadata["sha256"], file_size=metadata["size"],
                 file_display_name='file_display_name',
                 file_description='repo artifact `{}`'.format(metadata["filename"]),
                 check_acl=True, user_id=user_id,
                 scope_repo_id=repo_id
             )
             Session().add(entry)
             Session().commit()
 
         else:
             status = 404
 
         response = self.app.get(route_path('download_file', fid=store_uid), status=status)
 
         if exists:
             assert response.text == content
             file_store_path = os.path.dirname(store.resolve_name(store_uid, store_path)[1])
             metadata_file = os.path.join(file_store_path, store_uid + '.meta')
             assert os.path.exists(metadata_file)
             with open(metadata_file, 'rb') as f:
                 json_data = json.loads(f.read())
 
             assert json_data
             assert 'size' in json_data
 
     def test_upload_files_without_content_to_store(self):
         self.log_user()
         response = self.app.post(
             route_path('upload_file'),
             params={'csrf_token': self.csrf_token},
             status=200)
 
         assert response.json == {
             'error': 'store_file data field is missing',
             'access_path': None,
             'store_fid': None}
 
     def test_upload_files_bogus_content_to_store(self):
         self.log_user()
         response = self.app.post(
             route_path('upload_file'),
             params={'csrf_token': self.csrf_token, 'store_file': 'bogus'},
             status=200)
 
         assert response.json == {
             'error': 'filename cannot be read from the data field',
             'access_path': None,
             'store_fid': None}
 
     def test_upload_content_to_store(self):
         self.log_user()
         response = self.app.post(
             route_path('upload_file'),
             upload_files=[('store_file', b'myfile.txt', b'SOME CONTENT')],
             params={'csrf_token': self.csrf_token},
             status=200)
 
         assert response.json['store_fid']
 
     @pytest.fixture()
     def create_artifact_factory(self, tmpdir):
         def factory(user_id, content):
             store_path = self.app._pyramid_settings[config_keys.store_path]
             store = utils.get_file_storage({config_keys.store_path: store_path})
             fid = 'example.txt'
 
             filesystem_file = os.path.join(str(tmpdir), fid)
             with open(filesystem_file, 'wt') as f:
                 f.write(content)
 
             with open(filesystem_file, 'rb') as f:
                 store_uid, metadata = store.save_file(f, fid, extra_metadata={'filename': fid})
 
             entry = FileStore.create(
                 file_uid=store_uid, filename=metadata["filename"],
                 file_hash=metadata["sha256"], file_size=metadata["size"],
                 file_display_name='file_display_name',
                 file_description='repo artifact `{}`'.format(metadata["filename"]),
                 check_acl=True, user_id=user_id,
             )
             Session().add(entry)
             Session().commit()
             return entry
         return factory
 
     def test_download_file_non_scoped(self, user_util, create_artifact_factory):
         user = self.log_user()
         user_id = user['user_id']
         content = 'HELLO MY NAME IS ARTIFACT !'
 
         artifact = create_artifact_factory(user_id, content)
         file_uid = artifact.file_uid
         response = self.app.get(route_path('download_file', fid=file_uid), status=200)
         assert response.text == content
 
         # log-in to new user and test download again
         user = user_util.create_user(password='qweqwe')
         self.log_user(user.username, 'qweqwe')
         response = self.app.get(route_path('download_file', fid=file_uid), status=200)
         assert response.text == content
 
     def test_download_file_scoped_to_repo(self, user_util, create_artifact_factory):
         user = self.log_user()
         user_id = user['user_id']
         content = 'HELLO MY NAME IS ARTIFACT !'
 
         artifact = create_artifact_factory(user_id, content)
         # bind to repo
         repo = user_util.create_repo()
         repo_id = repo.repo_id
         artifact.scope_repo_id = repo_id
         Session().add(artifact)
         Session().commit()
 
         file_uid = artifact.file_uid
         response = self.app.get(route_path('download_file', fid=file_uid), status=200)
         assert response.text == content
 
         # log-in to new user and test download again
         user = user_util.create_user(password='qweqwe')
         self.log_user(user.username, 'qweqwe')
         response = self.app.get(route_path('download_file', fid=file_uid), status=200)
         assert response.text == content
 
         # forbid user the rights to repo
         repo = Repository.get(repo_id)
         user_util.grant_user_permission_to_repo(repo, user, 'repository.none')
         self.app.get(route_path('download_file', fid=file_uid), status=404)
 
     def test_download_file_scoped_to_user(self, user_util, create_artifact_factory):
         user = self.log_user()
         user_id = user['user_id']
         content = 'HELLO MY NAME IS ARTIFACT !'
 
         artifact = create_artifact_factory(user_id, content)
         # bind to user
         user = user_util.create_user(password='qweqwe')
 
         artifact.scope_user_id = user.user_id
         Session().add(artifact)
         Session().commit()
 
         # artifact creator doesn't have access since it's bind to another user
         file_uid = artifact.file_uid
         self.app.get(route_path('download_file', fid=file_uid), status=404)
 
         # log-in to new user and test download again, should be ok since we're bind to this artifact
         self.log_user(user.username, 'qweqwe')
         response = self.app.get(route_path('download_file', fid=file_uid), status=200)
         assert response.text == content
 
     def test_download_file_scoped_to_repo_with_bad_token(self, user_util, create_artifact_factory):
         user_id = User.get_first_super_admin().user_id
         content = 'HELLO MY NAME IS ARTIFACT !'
 
         artifact = create_artifact_factory(user_id, content)
         # bind to repo
         repo = user_util.create_repo()
         repo_id = repo.repo_id
         artifact.scope_repo_id = repo_id
         Session().add(artifact)
         Session().commit()
 
         file_uid = artifact.file_uid
         self.app.get(route_path('download_file_by_token',
                                 _auth_token='bogus', fid=file_uid), status=302)
 
     def test_download_file_scoped_to_repo_with_token(self, user_util, create_artifact_factory):
         user = User.get_first_super_admin()
         AuthTokenModel().create(user, 'test artifact token',
                                 role=AuthTokenModel.cls.ROLE_ARTIFACT_DOWNLOAD)
 
         user = User.get_first_super_admin()
         artifact_token = user.artifact_token
 
         user_id = User.get_first_super_admin().user_id
         content = 'HELLO MY NAME IS ARTIFACT !'
 
         artifact = create_artifact_factory(user_id, content)
         # bind to repo
         repo = user_util.create_repo()
         repo_id = repo.repo_id
         artifact.scope_repo_id = repo_id
         Session().add(artifact)
         Session().commit()
 
         file_uid = artifact.file_uid
         response = self.app.get(
             route_path('download_file_by_token',
                        _auth_token=artifact_token, fid=file_uid), status=200)
         assert response.text == content

rhodecode/apps/gist/tests/test_admin_gists.py

@@ -1,389 +1,365 b''
 # 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 import helpers as h
 from rhodecode.model.db import User, Gist
 from rhodecode.model.gist import GistModel
 from rhodecode.model.meta import Session
 from rhodecode.tests import (
     TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,
     TestController, assert_session_flash)
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'gists_show': ADMIN_PREFIX + '/gists',
-        'gists_new': ADMIN_PREFIX + '/gists/new',
-        'gists_create': ADMIN_PREFIX + '/gists/create',
-        'gist_show': ADMIN_PREFIX + '/gists/{gist_id}',
-        'gist_delete': ADMIN_PREFIX + '/gists/{gist_id}/delete',
-        'gist_edit': ADMIN_PREFIX + '/gists/{gist_id}/edit',
-        'gist_edit_check_revision': ADMIN_PREFIX + '/gists/{gist_id}/edit/check_revision',
-        'gist_update': ADMIN_PREFIX + '/gists/{gist_id}/update',
-        'gist_show_rev': ADMIN_PREFIX + '/gists/{gist_id}/rev/{revision}',
-        'gist_show_formatted': ADMIN_PREFIX + '/gists/{gist_id}/rev/{revision}/{format}',
-        'gist_show_formatted_path': ADMIN_PREFIX + '/gists/{gist_id}/rev/{revision}/{format}/{f_path}',
-
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests.routes import route_path
 
 
 class GistUtility(object):
 
     def __init__(self):
         self._gist_ids = []
 
     def __call__(
             self, f_name: bytes, content: bytes = b'some gist', lifetime=-1,
             description='gist-desc', gist_type='public',
             acl_level=Gist.GIST_PUBLIC, owner=TEST_USER_ADMIN_LOGIN):
         gist_mapping = {
             f_name: {'content': content}
         }
         user = User.get_by_username(owner)
         gist = GistModel().create(
             description, owner=user, gist_mapping=gist_mapping,
             gist_type=gist_type, lifetime=lifetime, gist_acl_level=acl_level)
         Session().commit()
         self._gist_ids.append(gist.gist_id)
         return gist
 
     def cleanup(self):
         for gist_id in self._gist_ids:
             gist = Gist.get(gist_id)
             if gist:
                 Session().delete(gist)
 
         Session().commit()
 
 
 @pytest.fixture()
 def create_gist(request):
     gist_utility = GistUtility()
     request.addfinalizer(gist_utility.cleanup)
     return gist_utility
 
 
 class TestGistsController(TestController):
 
     def test_index_empty(self, create_gist):
         self.log_user()
         response = self.app.get(route_path('gists_show'))
         response.mustcontain('var gist_data = [];')
 
     def test_index(self, create_gist):
         self.log_user()
         g1 = create_gist(b'gist1')
         g2 = create_gist(b'gist2', lifetime=1400)
         g3 = create_gist(b'gist3', description='gist3-desc')
         g4 = create_gist(b'gist4', gist_type='private').gist_access_id
         response = self.app.get(route_path('gists_show'))
 
         response.mustcontain(g1.gist_access_id)
         response.mustcontain(g2.gist_access_id)
         response.mustcontain(g3.gist_access_id)
         response.mustcontain('gist3-desc')
         response.mustcontain(no=[g4])
 
         # Expiration information should be visible
         expires_tag = str(h.age_component(h.time_to_utcdatetime(g2.gist_expires)))
         response.mustcontain(expires_tag.replace('"', '\\"'))
 
     def test_index_private_gists(self, create_gist):
         self.log_user()
         gist = create_gist(b'gist5', gist_type='private')
         response = self.app.get(route_path('gists_show', params=dict(private=1)))
 
         # and privates
         response.mustcontain(gist.gist_access_id)
 
     def test_index_show_all(self, create_gist):
         self.log_user()
         create_gist(b'gist1')
         create_gist(b'gist2', lifetime=1400)
         create_gist(b'gist3', description='gist3-desc')
         create_gist(b'gist4', gist_type='private')
 
         response = self.app.get(route_path('gists_show', params=dict(all=1)))
 
         assert len(GistModel.get_all()) == 4
         # and privates
         for gist in GistModel.get_all():
             response.mustcontain(gist.gist_access_id)
 
     def test_index_show_all_hidden_from_regular(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         create_gist(b'gist2', gist_type='private')
         create_gist(b'gist3', gist_type='private')
         create_gist(b'gist4', gist_type='private')
 
         response = self.app.get(route_path('gists_show', params=dict(all=1)))
 
         assert len(GistModel.get_all()) == 3
         # since we don't have access to private in this view, we
         # should see nothing
         for gist in GistModel.get_all():
             response.mustcontain(no=[gist.gist_access_id])
 
     def test_create(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'gist test',
                     'filename': 'foo',
                     'gist_type': 'public',
                     'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
                     'csrf_token': self.csrf_token},
             status=302)
         response = response.follow()
         response.mustcontain('added file: foo')
         response.mustcontain('gist test')
 
     def test_create_with_path_with_dirs(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'gist test',
                     'filename': '/home/foo',
                     'gist_type': 'public',
                     'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
                     'csrf_token': self.csrf_token},
             status=200)
         response.mustcontain('Filename /home/foo cannot be inside a directory')
 
     def test_access_expired_gist(self, create_gist):
         self.log_user()
         gist = create_gist(b'never-see-me')
         gist.gist_expires = 0  # 1970
         Session().add(gist)
         Session().commit()
 
         self.app.get(route_path('gist_show', gist_id=gist.gist_access_id),
                      status=404)
 
     def test_create_private(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'private gist test',
                     'filename': 'private-foo',
                     'gist_type': 'private',
                     'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
                     'csrf_token': self.csrf_token},
             status=302)
         response = response.follow()
         response.mustcontain('added file: private-foo<')
         response.mustcontain('private gist test')
         response.mustcontain('Private Gist')
         # Make sure private gists are not indexed by robots
         response.mustcontain(
             '<meta name="robots" content="noindex, nofollow">')
 
     def test_create_private_acl_private(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'private gist test',
                     'filename': 'private-foo',
                     'gist_type': 'private',
                     'gist_acl_level': Gist.ACL_LEVEL_PRIVATE,
                     'csrf_token': self.csrf_token},
             status=302)
         response = response.follow()
         response.mustcontain('added file: private-foo<')
         response.mustcontain('private gist test')
         response.mustcontain('Private Gist')
         # Make sure private gists are not indexed by robots
         response.mustcontain(
             '<meta name="robots" content="noindex, nofollow">')
 
     def test_create_with_description(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'gist test',
                     'filename': 'foo-desc',
                     'description': 'gist-desc',
                     'gist_type': 'public',
                     'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
                     'csrf_token': self.csrf_token},
              status=302)
         response = response.follow()
         response.mustcontain('added file: foo-desc')
         response.mustcontain('gist test')
         response.mustcontain('gist-desc')
 
     def test_create_public_with_anonymous_access(self):
         self.log_user()
         params = {
             'lifetime': -1,
             'content': 'gist test',
             'filename': 'foo-desc',
             'description': 'gist-desc',
             'gist_type': 'public',
             'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
             'csrf_token': self.csrf_token
         }
         response = self.app.post(
             route_path('gists_create'), params=params, status=302)
         self.logout_user()
         response = response.follow()
         response.mustcontain('added file: foo-desc')
         response.mustcontain('gist test')
         response.mustcontain('gist-desc')
 
     def test_new(self):
         self.log_user()
         self.app.get(route_path('gists_new'))
 
     def test_delete(self, create_gist):
         self.log_user()
         gist = create_gist(b'delete-me')
         response = self.app.post(
             route_path('gist_delete', gist_id=gist.gist_id),
             params={'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Deleted gist %s' % gist.gist_id)
 
     def test_delete_normal_user_his_gist(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         gist = create_gist(b'delete-me', owner=TEST_USER_REGULAR_LOGIN)
 
         response = self.app.post(
             route_path('gist_delete', gist_id=gist.gist_id),
             params={'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Deleted gist %s' % gist.gist_id)
 
     def test_delete_normal_user_not_his_own_gist(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         gist = create_gist(b'delete-me-2')
 
         self.app.post(
             route_path('gist_delete', gist_id=gist.gist_id),
             params={'csrf_token': self.csrf_token}, status=404)
 
     def test_show(self, create_gist):
         gist = create_gist(b'gist-show-me')
         response = self.app.get(route_path('gist_show', gist_id=gist.gist_access_id))
 
         response.mustcontain('added file: gist-show-me<')
 
         assert_response = response.assert_response()
         assert_response.element_equals_to(
             'div.rc-user span.user',
             '<a href="/_profiles/test_admin">test_admin</a>')
 
         response.mustcontain('gist-desc')
 
     def test_show_without_hg(self, create_gist):
         with mock.patch(
                 'rhodecode.lib.vcs.settings.ALIASES', ['git']):
             gist = create_gist(b'gist-show-me-again')
             self.app.get(
                 route_path('gist_show', gist_id=gist.gist_access_id), status=200)
 
     def test_show_acl_private(self, create_gist):
         gist = create_gist(b'gist-show-me-only-when-im-logged-in',
                            acl_level=Gist.ACL_LEVEL_PRIVATE)
         self.app.get(
             route_path('gist_show', gist_id=gist.gist_access_id), status=404)
 
         # now we log-in we should see thi gist
         self.log_user()
         response = self.app.get(
             route_path('gist_show', gist_id=gist.gist_access_id))
         response.mustcontain('added file: gist-show-me-only-when-im-logged-in')
 
         assert_response = response.assert_response()
         assert_response.element_equals_to(
             'div.rc-user span.user',
             '<a href="/_profiles/test_admin">test_admin</a>')
         response.mustcontain('gist-desc')
 
     def test_show_as_raw(self, create_gist):
         gist = create_gist(b'gist-show-me', content=b'GIST CONTENT')
         response = self.app.get(
             route_path('gist_show_formatted',
                        gist_id=gist.gist_access_id, revision='tip',
                        format='raw'))
         assert response.text == 'GIST CONTENT'
 
     def test_show_as_raw_individual_file(self, create_gist):
         gist = create_gist(b'gist-show-me-raw', content=b'GIST BODY')
         response = self.app.get(
             route_path('gist_show_formatted_path',
                        gist_id=gist.gist_access_id, format='raw',
                        revision='tip', f_path='gist-show-me-raw'))
         assert response.text == 'GIST BODY'
 
     def test_edit_page(self, create_gist):
         self.log_user()
         gist = create_gist(b'gist-for-edit', content=b'GIST EDIT BODY')
         response = self.app.get(route_path('gist_edit', gist_id=gist.gist_access_id))
         response.mustcontain('GIST EDIT BODY')
 
     def test_edit_page_non_logged_user(self, create_gist):
         gist = create_gist(b'gist-for-edit', content=b'GIST EDIT BODY')
         self.app.get(route_path('gist_edit', gist_id=gist.gist_access_id),
                      status=302)
 
     def test_edit_normal_user_his_gist(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         gist = create_gist(b'gist-for-edit', owner=TEST_USER_REGULAR_LOGIN)
         self.app.get(route_path('gist_edit', gist_id=gist.gist_access_id,
                                 status=200))
 
     def test_edit_normal_user_not_his_own_gist(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         gist = create_gist(b'delete-me')
         self.app.get(route_path('gist_edit', gist_id=gist.gist_access_id),
                      status=404)
 
     def test_user_first_name_is_escaped(self, user_util, create_gist):
         xss_atack_string = '"><script>alert(\'First Name\')</script>'
         xss_escaped_string = h.html_escape(h.escape(xss_atack_string))
         password = 'test'
         user = user_util.create_user(
             firstname=xss_atack_string, password=password)
         create_gist(b'gist', gist_type='public', owner=user.username)
         response = self.app.get(route_path('gists_show'))
         response.mustcontain(xss_escaped_string)
 
     def test_user_last_name_is_escaped(self, user_util, create_gist):
         xss_atack_string = '"><script>alert(\'Last Name\')</script>'
         xss_escaped_string = h.html_escape(h.escape(xss_atack_string))
         password = 'test'
         user = user_util.create_user(
             lastname=xss_atack_string, password=password)
         create_gist(b'gist', gist_type='public', owner=user.username)
         response = self.app.get(route_path('gists_show'))
         response.mustcontain(xss_escaped_string)

rhodecode/apps/home/tests/test_get_goto_switched_data.py

@@ -1,179 +1,167 b''
 # Copyright (C) 2016-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 . import assert_and_get_main_filter_content
-from rhodecode.tests import TestController, TEST_USER_ADMIN_LOGIN
-from rhodecode.tests.fixture import Fixture
 
 from rhodecode.lib.utils import map_groups
 from rhodecode.lib.ext_json import json
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.db import Session, Repository, RepoGroup
 
-fixture = Fixture()
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
+from rhodecode.tests import TestController, TEST_USER_ADMIN_LOGIN
+from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
 
-    base_url = {
-        'goto_switcher_data': '/_goto_data',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+fixture = Fixture()
 
 
 class TestGotoSwitcherData(TestController):
 
     required_repos_with_groups = [
         'abc',
         'abc-fork',
         'forks/abcd',
         'abcd',
         'abcde',
         'a/abc',
         'aa/abc',
         'aaa/abc',
         'aaaa/abc',
         'repos_abc/aaa/abc',
         'abc_repos/abc',
         'abc_repos/abcd',
         'xxx/xyz',
         'forked-abc/a/abc'
     ]
 
     @pytest.fixture(autouse=True, scope='class')
     def prepare(self, request, baseapp):
         for repo_and_group in self.required_repos_with_groups:
             # create structure of groups and return the last group
 
             repo_group = map_groups(repo_and_group)
 
             RepoModel()._create_repo(
                 repo_and_group, 'hg', 'test-ac', TEST_USER_ADMIN_LOGIN,
                 repo_group=getattr(repo_group, 'group_id', None))
 
             Session().commit()
 
         request.addfinalizer(self.cleanup)
 
     def cleanup(self):
         # first delete all repos
         for repo_and_groups in self.required_repos_with_groups:
             repo = Repository.get_by_repo_name(repo_and_groups)
             if repo:
                 RepoModel().delete(repo)
                 Session().commit()
 
         # then delete all empty groups
         for repo_and_groups in self.required_repos_with_groups:
             if '/' in repo_and_groups:
                 r_group = repo_and_groups.rsplit('/', 1)[0]
                 repo_group = RepoGroup.get_by_group_name(r_group)
                 if not repo_group:
                     continue
                 parents = repo_group.parents
                 RepoGroupModel().delete(repo_group, force_delete=True)
                 Session().commit()
 
                 for el in reversed(parents):
                     RepoGroupModel().delete(el, force_delete=True)
                     Session().commit()
 
     def test_empty_query(self, xhr_header):
         self.log_user()
 
         response = self.app.get(
             route_path('goto_switcher_data'),
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)['suggestions']
 
         assert result == []
 
     def test_returns_list_of_repos_and_groups_filtered(self, xhr_header):
         self.log_user()
 
         response = self.app.get(
             route_path('goto_switcher_data'),
             params={'query': 'abc'},
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)['suggestions']
 
         repos, groups, users, commits = assert_and_get_main_filter_content(result)
 
         assert len(repos) == 13
         assert len(groups) == 5
         assert len(users) == 0
         assert len(commits) == 0
 
     def test_returns_list_of_users_filtered(self, xhr_header):
         self.log_user()
 
         response = self.app.get(
             route_path('goto_switcher_data'),
             params={'query': 'user:admin'},
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)['suggestions']
 
         repos, groups, users, commits = assert_and_get_main_filter_content(result)
 
         assert len(repos) == 0
         assert len(groups) == 0
         assert len(users) == 1
         assert len(commits) == 0
 
     def test_returns_list_of_commits_filtered(self, xhr_header):
         self.log_user()
 
         response = self.app.get(
             route_path('goto_switcher_data'),
             params={'query': 'commit:e8'},
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)['suggestions']
 
         repos, groups, users, commits = assert_and_get_main_filter_content(result)
 
         assert len(repos) == 0
         assert len(groups) == 0
         assert len(users) == 0
         assert len(commits) == 5
 
     def test_returns_list_of_properly_sorted_and_filtered(self, xhr_header):
         self.log_user()
 
         response = self.app.get(
             route_path('goto_switcher_data'),
             params={'query': 'abc'},
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)['suggestions']
 
         repos, groups, users, commits = assert_and_get_main_filter_content(result)
 
         test_repos = [x['value_display'] for x in repos[:4]]
         assert ['abc', 'abcd', 'a/abc', 'abcde'] == test_repos
 
         test_groups = [x['value_display'] for x in groups[:4]]
         assert ['abc_repos', 'repos_abc',
                 'forked-abc', 'forked-abc/a'] == test_groups

rhodecode/apps/home/tests/test_get_repo_list_data.py

@@ -1,95 +1,83 b''
 # Copyright (C) 2016-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/
 
 from . import assert_and_get_repo_list_content
-from rhodecode.tests import TestController
-from rhodecode.tests.fixture import Fixture
+
 from rhodecode.model.db import Repository
 from rhodecode.lib.ext_json import json
 
+from rhodecode.tests import TestController
+from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'repo_list_data': '/_repos',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 class TestRepoListData(TestController):
 
     def test_returns_list_of_repos_and_groups(self, xhr_header):
         self.log_user()
 
         response = self.app.get(
             route_path('repo_list_data'),
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)['results']
 
         repos = assert_and_get_repo_list_content(result)
 
         assert len(repos) == len(Repository.get_all())
 
     def test_returns_list_of_repos_and_groups_filtered(self, xhr_header):
         self.log_user()
 
         response = self.app.get(
             route_path('repo_list_data'),
             params={'query': 'vcs_test_git'},
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)['results']
 
         repos = assert_and_get_repo_list_content(result)
 
         assert len(repos) == len(Repository.query().filter(
             Repository.repo_name.ilike('%vcs_test_git%')).all())
 
     def test_returns_list_of_repos_and_groups_filtered_with_type(self, xhr_header):
         self.log_user()
 
         response = self.app.get(
             route_path('repo_list_data'),
             params={'query': 'vcs_test_git', 'repo_type': 'git'},
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)['results']
 
         repos = assert_and_get_repo_list_content(result)
 
         assert len(repos) == len(Repository.query().filter(
             Repository.repo_name.ilike('%vcs_test_git%')).all())
 
     def test_returns_list_of_repos_non_ascii_query(self, xhr_header):
         self.log_user()
         response = self.app.get(
             route_path('repo_list_data'),
             params={'query': 'ć_vcs_test_ą', 'repo_type': 'git'},
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)['results']
 
         repos = assert_and_get_repo_list_content(result)
 
         assert len(repos) == 0

rhodecode/apps/home/tests/test_get_user_data.py

@@ -1,110 +1,97 b''
 # Copyright (C) 2016-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.ext_json import json
+
 from rhodecode.tests import TestController
 from rhodecode.tests.fixture import Fixture
-from rhodecode.lib.ext_json import json
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'user_autocomplete_data': '/_users',
-        'user_group_autocomplete_data': '/_user_groups'
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 class TestUserAutocompleteData(TestController):
 
     def test_returns_list_of_users(self, user_util, xhr_header):
         self.log_user()
         user = user_util.create_user(active=True)
         user_name = user.username
         response = self.app.get(
             route_path('user_autocomplete_data'),
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)
         values = [suggestion['value'] for suggestion in result['suggestions']]
         assert user_name in values
 
     def test_returns_inactive_users_when_active_flag_sent(
             self, user_util, xhr_header):
         self.log_user()
         user = user_util.create_user(active=False)
         user_name = user.username
 
         response = self.app.get(
             route_path('user_autocomplete_data',
                        params=dict(user_groups='true', active='0')),
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)
         values = [suggestion['value'] for suggestion in result['suggestions']]
         assert user_name in values
 
         response = self.app.get(
             route_path('user_autocomplete_data',
                        params=dict(user_groups='true', active='1')),
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)
         values = [suggestion['value'] for suggestion in result['suggestions']]
         assert user_name not in values
 
     def test_returns_groups_when_user_groups_flag_sent(
             self, user_util, xhr_header):
         self.log_user()
         group = user_util.create_user_group(user_groups_active=True)
         group_name = group.users_group_name
         response = self.app.get(
             route_path('user_autocomplete_data',
                        params=dict(user_groups='true')),
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)
         values = [suggestion['value'] for suggestion in result['suggestions']]
         assert group_name in values
 
     @pytest.mark.parametrize('query, count', [
         ('hello1', 0),
         ('dev', 2),
     ])
     def test_result_is_limited_when_query_is_sent(self, user_util, xhr_header,
                                                   query, count):
         self.log_user()
 
         user_util._test_name = 'dev-test'
         user_util.create_user()
 
         user_util._test_name = 'dev-group-test'
         user_util.create_user_group()
 
         response = self.app.get(
             route_path('user_autocomplete_data',
                        params=dict(user_groups='true', query=query)),
             extra_environ=xhr_header, status=200)
 
         result = json.loads(response.body)
         assert len(result['suggestions']) == count

rhodecode/apps/home/tests/test_get_user_group_data.py

@@ -1,116 +1,102 b''
 # Copyright (C) 2016-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/
 
 
 # Copyright (C) 2016-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.ext_json import json
+
 from rhodecode.tests import TestController
 from rhodecode.tests.fixture import Fixture
-from rhodecode.lib.ext_json import json
-
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'user_autocomplete_data': '/_users',
-        'user_group_autocomplete_data': '/_user_groups'
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 class TestUserGroupAutocompleteData(TestController):
 
     def test_returns_list_of_user_groups(self, user_util, xhr_header):
         self.log_user()
         user_group = user_util.create_user_group(active=True)
         user_group_name = user_group.users_group_name
         response = self.app.get(
             route_path('user_group_autocomplete_data'),
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)
         values = [suggestion['value'] for suggestion in result['suggestions']]
         assert user_group_name in values
 
     def test_returns_inactive_user_groups_when_active_flag_sent(
             self, user_util, xhr_header):
         self.log_user()
         user_group = user_util.create_user_group(active=False)
         user_group_name = user_group.users_group_name
 
         response = self.app.get(
             route_path('user_group_autocomplete_data',
                        params=dict(active='0')),
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)
         values = [suggestion['value'] for suggestion in result['suggestions']]
         assert user_group_name in values
 
         response = self.app.get(
             route_path('user_group_autocomplete_data',
                        params=dict(active='1')),
             extra_environ=xhr_header, status=200)
         result = json.loads(response.body)
         values = [suggestion['value'] for suggestion in result['suggestions']]
         assert user_group_name not in values
 
     @pytest.mark.parametrize('query, count', [
         ('hello1', 0),
         ('dev', 1),
     ])
     def test_result_is_limited_when_query_is_sent(self, user_util, xhr_header, query, count):
         self.log_user()
 
         user_util._test_name = 'dev-test'
         user_util.create_user_group()
 
         response = self.app.get(
             route_path('user_group_autocomplete_data',
                        params=dict(user_groups='true',
                                    query=query)),
             extra_environ=xhr_header, status=200)
 
         result = json.loads(response.body)
 
         assert len(result['suggestions']) == count

rhodecode/apps/home/tests/test_home.py

@@ -1,177 +1,167 b''
 # 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 rhodecode
 from rhodecode.model.db import Repository, RepoGroup, User
 from rhodecode.model.meta import Session
-from rhodecode.model.repo import RepoModel
-from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.settings import SettingsModel
 from rhodecode.tests import TestController
 from rhodecode.tests.fixture import Fixture
-from rhodecode.lib import helpers as h
-
-fixture = Fixture()
+from rhodecode.tests.routes import route_path
 
 
-def route_path(name, **kwargs):
-    return {
-        'home': '/',
-        'main_page_repos_data': '/_home_repos',
-        'main_page_repo_groups_data': '/_home_repo_groups',
-        'repo_group_home': '/{repo_group_name}'
-    }[name].format(**kwargs)
+fixture = Fixture()
 
 
 class TestHomeController(TestController):
 
     def test_index(self):
         self.log_user()
         response = self.app.get(route_path('home'))
         # if global permission is set
         response.mustcontain('New Repository')
 
     def test_index_grid_repos(self, xhr_header):
         self.log_user()
         response = self.app.get(route_path('main_page_repos_data'), extra_environ=xhr_header)
         # search for objects inside the JavaScript JSON
         for obj in Repository.getAll():
             response.mustcontain('<a href=\\"/{}\\">'.format(obj.repo_name))
 
     def test_index_grid_repo_groups(self, xhr_header):
         self.log_user()
         response = self.app.get(route_path('main_page_repo_groups_data'),
                                 extra_environ=xhr_header,)
 
         # search for objects inside the JavaScript JSON
         for obj in RepoGroup.getAll():
             response.mustcontain('<a href=\\"/{}\\">'.format(obj.group_name))
 
     def test_index_grid_repo_groups_without_access(self, xhr_header, user_util):
         user = user_util.create_user(password='qweqwe')
         group_ok = user_util.create_repo_group(owner=user)
         group_id_ok = group_ok.group_id
 
         group_forbidden = user_util.create_repo_group(owner=User.get_first_super_admin())
         group_id_forbidden = group_forbidden.group_id
 
         user_util.grant_user_permission_to_repo_group(group_forbidden, user, 'group.none')
         self.log_user(user.username, 'qweqwe')
 
         self.app.get(route_path('main_page_repo_groups_data'),
                      extra_environ=xhr_header,
                      params={'repo_group_id': group_id_ok}, status=200)
 
         self.app.get(route_path('main_page_repo_groups_data'),
                      extra_environ=xhr_header,
                      params={'repo_group_id': group_id_forbidden}, status=404)
 
     def test_index_contains_statics_with_ver(self):
         from rhodecode.lib.base import calculate_version_hash
 
         self.log_user()
         response = self.app.get(route_path('home'))
 
         rhodecode_version_hash = calculate_version_hash(
             {'beaker.session.secret': 'test-rc-uytcxaz'})
         response.mustcontain('style.css?ver={0}'.format(rhodecode_version_hash))
         response.mustcontain('scripts.min.js?ver={0}'.format(rhodecode_version_hash))
 
     def test_index_contains_backend_specific_details(self, backend, xhr_header):
         self.log_user()
         response = self.app.get(route_path('main_page_repos_data'), extra_environ=xhr_header)
         tip = backend.repo.get_commit().raw_id
 
         # html in javascript variable:
         response.mustcontain(r'<i class=\"icon-%s\"' % (backend.alias, ))
         response.mustcontain(r'href=\"/%s\"' % (backend.repo_name, ))
 
         response.mustcontain("""/%s/changeset/%s""" % (backend.repo_name, tip))
         response.mustcontain("""Added a symlink""")
 
     def test_index_with_anonymous_access_disabled(self):
         with fixture.anon_access(False):
             response = self.app.get(route_path('home'), status=302)
             assert 'login' in response.location
 
     def test_index_page_on_groups_with_wrong_group_id(self, autologin_user, xhr_header):
         group_id = 918123
         self.app.get(
             route_path('main_page_repo_groups_data'),
             params={'repo_group_id': group_id},
             status=404, extra_environ=xhr_header)
 
     def test_index_page_on_groups(self, autologin_user, user_util, xhr_header):
         gr = user_util.create_repo_group()
         repo = user_util.create_repo(parent=gr)
         repo_name = repo.repo_name
         group_id = gr.group_id
 
         response = self.app.get(route_path(
             'repo_group_home', repo_group_name=gr.group_name))
         response.mustcontain('d.repo_group_id = {}'.format(group_id))
 
         response = self.app.get(
             route_path('main_page_repos_data'),
             params={'repo_group_id': group_id},
             extra_environ=xhr_header,)
         response.mustcontain(repo_name)
 
     def test_index_page_on_group_with_trailing_slash(self, autologin_user, user_util, xhr_header):
         gr = user_util.create_repo_group()
         repo = user_util.create_repo(parent=gr)
         repo_name = repo.repo_name
         group_id = gr.group_id
 
         response = self.app.get(route_path(
             'repo_group_home', repo_group_name=gr.group_name+'/'))
         response.mustcontain('d.repo_group_id = {}'.format(group_id))
 
         response = self.app.get(
             route_path('main_page_repos_data'),
             params={'repo_group_id': group_id},
             extra_environ=xhr_header, )
         response.mustcontain(repo_name)
 
     @pytest.mark.parametrize("name, state", [
         ('Disabled', False),
         ('Enabled', True),
     ])
     def test_index_show_version(self, autologin_user, name, state):
         version_string = 'RhodeCode %s' % rhodecode.__version__
 
         sett = SettingsModel().create_or_update_setting(
             'show_version', state, 'bool')
         Session().add(sett)
         Session().commit()
         SettingsModel().invalidate_settings_cache(hard=True)
 
         response = self.app.get(route_path('home'))
         if state is True:
             response.mustcontain(version_string)
         if state is False:
             response.mustcontain(no=[version_string])
 
     def test_logout_form_contains_csrf(self, autologin_user, csrf_token):
         response = self.app.get(route_path('home'))
         assert_response = response.assert_response()
         element = assert_response.get_element('.logout [name=csrf_token]')
         assert element.value == csrf_token

rhodecode/apps/journal/tests/test_journal.py

@@ -1,107 +1,87 b''
 
 # 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 datetime
 
 import pytest
 
 from rhodecode.apps._base import ADMIN_PREFIX
-from rhodecode.tests import TestController
 from rhodecode.model.db import UserFollowing, Repository
 
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'journal': ADMIN_PREFIX + '/journal',
-        'journal_rss': ADMIN_PREFIX + '/journal/rss',
-        'journal_atom': ADMIN_PREFIX + '/journal/atom',
-        'journal_public': ADMIN_PREFIX + '/public_journal',
-        'journal_public_atom': ADMIN_PREFIX + '/public_journal/atom',
-        'journal_public_atom_old': ADMIN_PREFIX + '/public_journal_atom',
-        'journal_public_rss': ADMIN_PREFIX + '/public_journal/rss',
-        'journal_public_rss_old': ADMIN_PREFIX + '/public_journal_rss',
-        'toggle_following': ADMIN_PREFIX + '/toggle_following',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests import TestController
+from rhodecode.tests.routes import route_path
 
 
 class TestJournalViews(TestController):
 
     def test_journal(self):
         self.log_user()
         response = self.app.get(route_path('journal'))
         # response.mustcontain(
         #     """<div class="journal_day">%s</div>""" % datetime.date.today())
 
     @pytest.mark.parametrize("feed_type, content_type", [
         ('rss', "application/rss+xml"),
         ('atom', "application/atom+xml")
     ])
     def test_journal_feed(self, feed_type, content_type):
         self.log_user()
         response = self.app.get(
             route_path(
                 'journal_{}'.format(feed_type)),
             status=200)
 
         assert response.content_type == content_type
 
     def test_toggle_following_repository(self, backend):
         user = self.log_user()
         repo = Repository.get_by_repo_name(backend.repo_name)
         repo_id = repo.repo_id
         self.app.post(
             route_path('toggle_following'), {'follows_repo_id': repo_id,
                                              'csrf_token': self.csrf_token})
 
         followings = UserFollowing.query()\
             .filter(UserFollowing.user_id == user['user_id'])\
             .filter(UserFollowing.follows_repo_id == repo_id).all()
 
         assert len(followings) == 0
 
         self.app.post(
             route_path('toggle_following'), {'follows_repo_id': repo_id,
                                              'csrf_token': self.csrf_token})
 
         followings = UserFollowing.query()\
             .filter(UserFollowing.user_id == user['user_id'])\
             .filter(UserFollowing.follows_repo_id == repo_id).all()
 
         assert len(followings) == 1
 
     @pytest.mark.parametrize("feed_type, content_type", [
         ('rss', "application/rss+xml"),
         ('atom', "application/atom+xml")
     ])
     def test_public_journal_feed(self, feed_type, content_type):
         self.log_user()
         response = self.app.get(
             route_path(
                 'journal_public_{}'.format(feed_type)),
             status=200)
 
         assert response.content_type == content_type

rhodecode/apps/login/tests/test_login.py

@@ -1,607 +1,581 b''
 # 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 urllib.parse
 
 import mock
 import pytest
 
-from rhodecode.tests import (
-    assert_session_flash, HG_REPO, TEST_USER_ADMIN_LOGIN,
-    no_newline_id_generator)
-from rhodecode.tests.fixture import Fixture
+
 from rhodecode.lib.auth import check_password
 from rhodecode.lib import helpers as h
 from rhodecode.model.auth_token import AuthTokenModel
 from rhodecode.model.db import User, Notification, UserApiKeys
 from rhodecode.model.meta import Session
 
+from rhodecode.tests import (
+    assert_session_flash, HG_REPO, TEST_USER_ADMIN_LOGIN,
+    no_newline_id_generator)
+from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
+
 fixture = Fixture()
 
 whitelist_view = ['RepoCommitsView:repo_commit_raw']
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'login': ADMIN_PREFIX + '/login',
-        'logout': ADMIN_PREFIX + '/logout',
-        'register': ADMIN_PREFIX + '/register',
-        'reset_password':
-            ADMIN_PREFIX + '/password_reset',
-        'reset_password_confirmation':
-            ADMIN_PREFIX + '/password_reset_confirmation',
-
-        'admin_permissions_application':
-            ADMIN_PREFIX + '/permissions/application',
-        'admin_permissions_application_update':
-            ADMIN_PREFIX + '/permissions/application/update',
-
-        'repo_commit_raw': '/{repo_name}/raw-changeset/{commit_id}'
-
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 @pytest.mark.usefixtures('app')
 class TestLoginController(object):
     destroy_users = set()
 
     @classmethod
     def teardown_class(cls):
         fixture.destroy_users(cls.destroy_users)
 
     def teardown_method(self, method):
         for n in Notification.query().all():
             Session().delete(n)
 
         Session().commit()
         assert Notification.query().all() == []
 
     def test_index(self):
         response = self.app.get(route_path('login'))
         assert response.status == '200 OK'
         # Test response...
 
     def test_login_admin_ok(self):
         response = self.app.post(route_path('login'),
                                  {'username': 'test_admin',
                                   'password': 'test12'}, status=302)
         response = response.follow()
         session = response.get_session_from_response()
         username = session['rhodecode_user'].get('username')
         assert username == 'test_admin'
         response.mustcontain('logout')
 
     def test_login_regular_ok(self):
         response = self.app.post(route_path('login'),
                                  {'username': 'test_regular',
                                   'password': 'test12'}, status=302)
 
         response = response.follow()
         session = response.get_session_from_response()
         username = session['rhodecode_user'].get('username')
         assert username == 'test_regular'
         response.mustcontain('logout')
 
     def test_login_regular_forbidden_when_super_admin_restriction(self):
         from rhodecode.authentication.plugins.auth_rhodecode import RhodeCodeAuthPlugin
         with fixture.auth_restriction(self.app._pyramid_registry,
                                       RhodeCodeAuthPlugin.AUTH_RESTRICTION_SUPER_ADMIN):
             response = self.app.post(route_path('login'),
                                      {'username': 'test_regular',
                                       'password': 'test12'})
 
             response.mustcontain('invalid user name')
             response.mustcontain('invalid password')
 
     def test_login_regular_forbidden_when_scope_restriction(self):
         from rhodecode.authentication.plugins.auth_rhodecode import RhodeCodeAuthPlugin
         with fixture.scope_restriction(self.app._pyramid_registry,
                                        RhodeCodeAuthPlugin.AUTH_RESTRICTION_SCOPE_VCS):
             response = self.app.post(route_path('login'),
                                      {'username': 'test_regular',
                                       'password': 'test12'})
 
             response.mustcontain('invalid user name')
             response.mustcontain('invalid password')
 
     def test_login_ok_came_from(self):
         test_came_from = '/_admin/users?branch=stable'
         _url = '{}?came_from={}'.format(route_path('login'), test_came_from)
         response = self.app.post(
             _url, {'username': 'test_admin', 'password': 'test12'}, status=302)
 
         assert 'branch=stable' in response.location
         response = response.follow()
 
         assert response.status == '200 OK'
         response.mustcontain('Users administration')
 
     def test_redirect_to_login_with_get_args(self):
         with fixture.anon_access(False):
             kwargs = {'branch': 'stable'}
             response = self.app.get(
                 h.route_path('repo_summary', repo_name=HG_REPO, _query=kwargs),
                 status=302)
 
             response_query = urllib.parse.parse_qsl(response.location)
             assert 'branch=stable' in response_query[0][1]
 
     def test_login_form_with_get_args(self):
         _url = '{}?came_from=/_admin/users,branch=stable'.format(route_path('login'))
         response = self.app.get(_url)
         assert 'branch%3Dstable' in response.form.action
 
     @pytest.mark.parametrize("url_came_from", [
         'data:text/html,<script>window.alert("xss")</script>',
         'mailto:[e-mail]',
         'file:///etc/passwd',
         'ftp://some.ftp.server',
         'http://other.domain',
     ], ids=no_newline_id_generator)
     def test_login_bad_came_froms(self, url_came_from):
         _url = '{}?came_from={}'.format(route_path('login'), url_came_from)
         response = self.app.post(
             _url, {'username': 'test_admin', 'password': 'test12'}, status=302)
         assert response.status == '302 Found'
         response = response.follow()
         assert response.status == '200 OK'
         assert response.request.path == '/'
 
     @pytest.mark.xfail(reason="newline params changed behaviour in python3")
     @pytest.mark.parametrize("url_came_from", [
         '/\r\nX-Forwarded-Host: \rhttp://example.org',
     ], ids=no_newline_id_generator)
     def test_login_bad_came_froms_404(self, url_came_from):
         _url = '{}?came_from={}'.format(route_path('login'), url_came_from)
         response = self.app.post(
             _url, {'username': 'test_admin', 'password': 'test12'}, status=302)
 
         response = response.follow()
         assert response.status == '404 Not Found'
 
     def test_login_short_password(self):
         response = self.app.post(route_path('login'),
                                  {'username': 'test_admin',
                                   'password': 'as'})
         assert response.status == '200 OK'
 
         response.mustcontain('Enter 3 characters or more')
 
     def test_login_wrong_non_ascii_password(self, user_regular):
         response = self.app.post(
             route_path('login'),
             {'username': user_regular.username,
              'password': 'invalid-non-asci\xe4'.encode('utf8')})
 
         response.mustcontain('invalid user name')
         response.mustcontain('invalid password')
 
     def test_login_with_non_ascii_password(self, user_util):
         password = u'valid-non-ascii\xe4'
         user = user_util.create_user(password=password)
         response = self.app.post(
             route_path('login'),
             {'username': user.username,
              'password': password})
         assert response.status_code == 302
 
     def test_login_wrong_username_password(self):
         response = self.app.post(route_path('login'),
                                  {'username': 'error',
                                   'password': 'test12'})
 
         response.mustcontain('invalid user name')
         response.mustcontain('invalid password')
 
     def test_login_admin_ok_password_migration(self, real_crypto_backend):
         from rhodecode.lib import auth
 
         # create new user, with sha256 password
         temp_user = 'test_admin_sha256'
         user = fixture.create_user(temp_user)
         user.password = auth._RhodeCodeCryptoSha256().hash_create(
             b'test123')
         Session().add(user)
         Session().commit()
         self.destroy_users.add(temp_user)
         response = self.app.post(route_path('login'),
                                  {'username': temp_user,
                                   'password': 'test123'}, status=302)
 
         response = response.follow()
         session = response.get_session_from_response()
         username = session['rhodecode_user'].get('username')
         assert username == temp_user
         response.mustcontain('logout')
 
         # new password should be bcrypted, after log-in and transfer
         user = User.get_by_username(temp_user)
         assert user.password.startswith('$')
 
     # REGISTRATIONS
     def test_register(self):
         response = self.app.get(route_path('register'))
         response.mustcontain('Create an Account')
 
     def test_register_err_same_username(self):
         uname = 'test_admin'
         response = self.app.post(
             route_path('register'),
             {
                 'username': uname,
                 'password': 'test12',
                 'password_confirmation': 'test12',
                 'email': '[e-mail]',
                 'firstname': 'test',
                 'lastname': 'test'
             }
         )
 
         assertr = response.assert_response()
         msg = 'Username "%(username)s" already exists'
         msg = msg % {'username': uname}
         assertr.element_contains('#username+.error-message', msg)
 
     def test_register_err_same_email(self):
         response = self.app.post(
             route_path('register'),
             {
                 'username': 'test_admin_0',
                 'password': 'test12',
                 'password_confirmation': 'test12',
                 'email': '[e-mail]',
                 'firstname': 'test',
                 'lastname': 'test'
             }
         )
 
         assertr = response.assert_response()
         msg = u'This e-mail address is already taken'
         assertr.element_contains('#email+.error-message', msg)
 
     def test_register_err_same_email_case_sensitive(self):
         response = self.app.post(
             route_path('register'),
             {
                 'username': 'test_admin_1',
                 'password': 'test12',
                 'password_confirmation': 'test12',
                 'email': '[e-mail]',
                 'firstname': 'test',
                 'lastname': 'test'
             }
         )
         assertr = response.assert_response()
         msg = u'This e-mail address is already taken'
         assertr.element_contains('#email+.error-message', msg)
 
     def test_register_err_wrong_data(self):
         response = self.app.post(
             route_path('register'),
             {
                 'username': 'xs',
                 'password': 'test',
                 'password_confirmation': 'test',
                 'email': 'goodmailm',
                 'firstname': 'test',
                 'lastname': 'test'
             }
         )
         assert response.status == '200 OK'
         response.mustcontain('An email address must contain a single @')
         response.mustcontain('Enter a value 6 characters long or more')
 
     def test_register_err_username(self):
         response = self.app.post(
             route_path('register'),
             {
                 'username': 'error user',
                 'password': 'test12',
                 'password_confirmation': 'test12',
                 'email': 'goodmailm',
                 'firstname': 'test',
                 'lastname': 'test'
             }
         )
 
         response.mustcontain('An email address must contain a single @')
         response.mustcontain(
             'Username may only contain '
             'alphanumeric characters underscores, '
             'periods or dashes and must begin with '
             'alphanumeric character')
 
     def test_register_err_case_sensitive(self):
         usr = 'Test_Admin'
         response = self.app.post(
             route_path('register'),
             {
                 'username': usr,
                 'password': 'test12',
                 'password_confirmation': 'test12',
                 'email': 'goodmailm',
                 'firstname': 'test',
                 'lastname': 'test'
             }
         )
 
         assertr = response.assert_response()
         msg = u'Username "%(username)s" already exists'
         msg = msg % {'username': usr}
         assertr.element_contains('#username+.error-message', msg)
 
     def test_register_special_chars(self):
         response = self.app.post(
             route_path('register'),
             {
                 'username': 'xxxaxn',
                 'password': 'ąćźżąśśśś',
                 'password_confirmation': 'ąćźżąśśśś',
                 'email': '[e-mail]',
                 'firstname': 'test',
                 'lastname': 'test'
             }
         )
 
         msg = u'Invalid characters (non-ascii) in password'
         response.mustcontain(msg)
 
     def test_register_password_mismatch(self):
         response = self.app.post(
             route_path('register'),
             {
                 'username': 'xs',
                 'password': '123qwe',
                 'password_confirmation': 'qwe123',
                 'email': '[e-mail]',
                 'firstname': 'test',
                 'lastname': 'test'
             }
         )
         msg = u'Passwords do not match'
         response.mustcontain(msg)
 
     def test_register_ok(self):
         username = 'test_regular4'
         password = 'qweqwe'
         email = '[e-mail]'
         name = 'testname'
         lastname = 'testlastname'
 
         # this initializes a session
         response = self.app.get(route_path('register'))
         response.mustcontain('Create an Account')
 
 
         response = self.app.post(
             route_path('register'),
             {
                 'username': username,
                 'password': password,
                 'password_confirmation': password,
                 'email': email,
                 'firstname': name,
                 'lastname': lastname,
                 'admin': True
             },
             status=302
         )  # This should be overridden
 
         assert_session_flash(
             response, 'You have successfully registered with RhodeCode. You can log-in now.')
 
         ret = Session().query(User).filter(
             User.username == 'test_regular4').one()
         assert ret.username == username
         assert check_password(password, ret.password)
         assert ret.email == email
         assert ret.name == name
         assert ret.lastname == lastname
         assert ret.auth_tokens is not None
         assert not ret.admin
 
     def test_forgot_password_wrong_mail(self):
         bad_email = '[e-mail]'
         # this initializes a session
         self.app.get(route_path('reset_password'))
 
         response = self.app.post(
             route_path('reset_password'), {'email': bad_email, }
         )
         assert_session_flash(response,
             'If such email exists, a password reset link was sent to it.')
 
     def test_forgot_password(self, user_util):
         # this initializes a session
         self.app.get(route_path('reset_password'))
 
         user = user_util.create_user()
         user_id = user.user_id
         email = user.email
 
         response = self.app.post(route_path('reset_password'), {'email': email, })
 
         assert_session_flash(response,
             'If such email exists, a password reset link was sent to it.')
 
         # BAD KEY
         confirm_url = '{}?key={}'.format(route_path('reset_password_confirmation'), 'badkey')
         response = self.app.get(confirm_url, status=302)
         assert response.location.endswith(route_path('reset_password'))
         assert_session_flash(response, 'Given reset token is invalid')
 
         response.follow()  # cleanup flash
 
         # GOOD KEY
         key = UserApiKeys.query()\
             .filter(UserApiKeys.user_id == user_id)\
             .filter(UserApiKeys.role == UserApiKeys.ROLE_PASSWORD_RESET)\
             .first()
 
         assert key
 
         confirm_url = '{}?key={}'.format(route_path('reset_password_confirmation'), key.api_key)
         response = self.app.get(confirm_url)
         assert response.status == '302 Found'
         assert response.location.endswith(route_path('login'))
 
         assert_session_flash(
             response,
             'Your password reset was successful, '
             'a new password has been sent to your email')
 
         response.follow()
 
     def _get_api_whitelist(self, values=None):
         config = {'api_access_controllers_whitelist': values or []}
         return config
 
     @pytest.mark.parametrize("test_name, auth_token", [
         ('none', None),
         ('empty_string', ''),
         ('fake_number', '123456'),
         ('proper_auth_token', None)
     ])
     def test_access_not_whitelisted_page_via_auth_token(
             self, test_name, auth_token, user_admin):
 
         whitelist = self._get_api_whitelist([])
         with mock.patch.dict('rhodecode.CONFIG', whitelist):
             assert [] == whitelist['api_access_controllers_whitelist']
             if test_name == 'proper_auth_token':
                 # use builtin if api_key is None
                 auth_token = user_admin.api_key
 
             with fixture.anon_access(False):
                 # webtest uses linter to check if response is bytes,
                 # and we use memoryview here as a wrapper, quick turn-off
                 self.app.lint = False
 
                 self.app.get(
                     route_path('repo_commit_raw',
                                repo_name=HG_REPO, commit_id='tip',
                                params=dict(api_key=auth_token)),
                     status=302)
 
     @pytest.mark.parametrize("test_name, auth_token, code", [
         ('none', None, 302),
         ('empty_string', '', 302),
         ('fake_number', '123456', 302),
         ('proper_auth_token', None, 200)
     ])
     def test_access_whitelisted_page_via_auth_token(
             self, test_name, auth_token, code, user_admin):
 
         whitelist = self._get_api_whitelist(whitelist_view)
 
         with mock.patch.dict('rhodecode.CONFIG', whitelist):
             assert whitelist_view == whitelist['api_access_controllers_whitelist']
 
             if test_name == 'proper_auth_token':
                 auth_token = user_admin.api_key
                 assert auth_token
 
             with fixture.anon_access(False):
                 # webtest uses linter to check if response is bytes,
                 # and we use memoryview here as a wrapper, quick turn-off
                 self.app.lint = False
                 self.app.get(
                     route_path('repo_commit_raw',
                                repo_name=HG_REPO, commit_id='tip',
                                params=dict(api_key=auth_token)),
                     status=code)
 
     @pytest.mark.parametrize("test_name, auth_token, code", [
         ('proper_auth_token', None, 200),
         ('wrong_auth_token', '123456', 302),
     ])
     def test_access_whitelisted_page_via_auth_token_bound_to_token(
             self, test_name, auth_token, code, user_admin):
 
         expected_token = auth_token
         if test_name == 'proper_auth_token':
             auth_token = user_admin.api_key
             expected_token = auth_token
             assert auth_token
 
         whitelist = self._get_api_whitelist([
             'RepoCommitsView:repo_commit_raw@{}'.format(expected_token)])
 
         with mock.patch.dict('rhodecode.CONFIG', whitelist):
 
             with fixture.anon_access(False):
                 # webtest uses linter to check if response is bytes,
                 # and we use memoryview here as a wrapper, quick turn-off
                 self.app.lint = False
 
                 self.app.get(
                     route_path('repo_commit_raw',
                                repo_name=HG_REPO, commit_id='tip',
                                params=dict(api_key=auth_token)),
                     status=code)
 
     def test_access_page_via_extra_auth_token(self):
         whitelist = self._get_api_whitelist(whitelist_view)
         with mock.patch.dict('rhodecode.CONFIG', whitelist):
             assert whitelist_view == \
                 whitelist['api_access_controllers_whitelist']
 
             new_auth_token = AuthTokenModel().create(
                 TEST_USER_ADMIN_LOGIN, 'test')
             Session().commit()
             with fixture.anon_access(False):
                 # webtest uses linter to check if response is bytes,
                 # and we use memoryview here as a wrapper, quick turn-off
                 self.app.lint = False
                 self.app.get(
                     route_path('repo_commit_raw',
                                repo_name=HG_REPO, commit_id='tip',
                                params=dict(api_key=new_auth_token.api_key)),
                     status=200)
 
     def test_access_page_via_expired_auth_token(self):
         whitelist = self._get_api_whitelist(whitelist_view)
         with mock.patch.dict('rhodecode.CONFIG', whitelist):
             assert whitelist_view == \
                 whitelist['api_access_controllers_whitelist']
 
             new_auth_token = AuthTokenModel().create(
                 TEST_USER_ADMIN_LOGIN, 'test')
             Session().commit()
             # patch the api key and make it expired
             new_auth_token.expires = 0
             Session().add(new_auth_token)
             Session().commit()
             with fixture.anon_access(False):
                 # webtest uses linter to check if response is bytes,
                 # and we use memoryview here as a wrapper, quick turn-off
                 self.app.lint = False
                 self.app.get(
                     route_path('repo_commit_raw',
                                repo_name=HG_REPO, commit_id='tip',
                                params=dict(api_key=new_auth_token.api_key)),
                     status=302)

rhodecode/apps/login/tests/test_password_reset.py

@@ -1,118 +1,94 b''
 # 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 import helpers as h
 from rhodecode.tests import (
     TestController, clear_cache_regions,
     TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
 from rhodecode.tests.fixture import Fixture
 from rhodecode.tests.utils import AssertResponse
-
-fixture = Fixture()
+from rhodecode.tests.routes import route_path
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'login': ADMIN_PREFIX + '/login',
-        'logout': ADMIN_PREFIX + '/logout',
-        'register': ADMIN_PREFIX + '/register',
-        'reset_password':
-            ADMIN_PREFIX + '/password_reset',
-        'reset_password_confirmation':
-            ADMIN_PREFIX + '/password_reset_confirmation',
-
-        'admin_permissions_application':
-            ADMIN_PREFIX + '/permissions/application',
-        'admin_permissions_application_update':
-            ADMIN_PREFIX + '/permissions/application/update',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+fixture = Fixture()
 
 
 class TestPasswordReset(TestController):
 
     @pytest.mark.parametrize(
         'pwd_reset_setting, show_link, show_reset', [
             ('hg.password_reset.enabled', True, True),
             ('hg.password_reset.hidden', False, True),
             ('hg.password_reset.disabled', False, False),
         ])
     def test_password_reset_settings(
             self, pwd_reset_setting, show_link, show_reset):
         clear_cache_regions()
         self.log_user(TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
         params = {
             'csrf_token': self.csrf_token,
             'anonymous': 'True',
             'default_register': 'hg.register.auto_activate',
             'default_register_message': '',
             'default_password_reset': pwd_reset_setting,
             'default_extern_activate': 'hg.extern_activate.auto',
         }
         resp = self.app.post(
             route_path('admin_permissions_application_update'), params=params)
         self.logout_user()
 
         login_page = self.app.get(route_path('login'))
         asr_login = AssertResponse(login_page)
 
         if show_link:
             asr_login.one_element_exists('a.pwd_reset')
         else:
             asr_login.no_element_exists('a.pwd_reset')
 
         response = self.app.get(route_path('reset_password'))
         
         assert_response = response.assert_response()
         if show_reset:
             response.mustcontain('Send password reset email')
             assert_response.one_element_exists('#email')
             assert_response.one_element_exists('#send')
         else:
             response.mustcontain('Password reset is disabled.')
             assert_response.no_element_exists('#email')
             assert_response.no_element_exists('#send')
 
     def test_password_form_disabled(self):
         self.log_user(TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
         params = {
             'csrf_token': self.csrf_token,
             'anonymous': 'True',
             'default_register': 'hg.register.auto_activate',
             'default_register_message': '',
             'default_password_reset': 'hg.password_reset.disabled',
             'default_extern_activate': 'hg.extern_activate.auto',
         }
         self.app.post(route_path('admin_permissions_application_update'), params=params)
         self.logout_user()
 
         response = self.app.post(
             route_path('reset_password'), {'email': '[e-mail]',}
         )
         response = response.follow()
         response.mustcontain('Password reset is disabled.')

rhodecode/apps/my_account/tests/test_my_account_auth_tokens.py

@@ -1,109 +1,98 b''
 # 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.apps._base import ADMIN_PREFIX
 from rhodecode.model.db import User
 from rhodecode.tests import (
-    TestController, route_path_generator, assert_session_flash)
+    TestController, assert_session_flash)
 from rhodecode.tests.fixture import Fixture
-from rhodecode.tests.utils import AssertResponse
-
-fixture = Fixture()
+from rhodecode.tests.routes import route_path
 
 
-def route_path(name, params=None, **kwargs):
-    url_defs = {
-        'my_account_auth_tokens':
-            ADMIN_PREFIX + '/my_account/auth_tokens',
-        'my_account_auth_tokens_add':
-            ADMIN_PREFIX + '/my_account/auth_tokens/new',
-        'my_account_auth_tokens_delete':
-            ADMIN_PREFIX + '/my_account/auth_tokens/delete',
-    }
-    return route_path_generator(url_defs, name=name, params=params, **kwargs)
+fixture = Fixture()
 
 
 class TestMyAccountAuthTokens(TestController):
 
     def test_my_account_auth_tokens(self):
         usr = self.log_user('test_regular2', 'test12')
         user = User.get(usr['user_id'])
         response = self.app.get(route_path('my_account_auth_tokens'))
         for token in user.auth_tokens:
             response.mustcontain(token[:4])
             response.mustcontain('never')
 
     def test_my_account_add_auth_tokens_wrong_csrf(self, user_util):
         user = user_util.create_user(password='qweqwe')
         self.log_user(user.username, 'qweqwe')
 
         self.app.post(
             route_path('my_account_auth_tokens_add'),
             {'description': 'desc', 'lifetime': -1}, status=403)
 
     @pytest.mark.parametrize("desc, lifetime", [
         ('forever', -1),
         ('5mins', 60*5),
         ('30days', 60*60*24*30),
     ])
     def test_my_account_add_auth_tokens(self, desc, lifetime, user_util):
         user = user_util.create_user(password='qweqwe')
         user_id = user.user_id
         self.log_user(user.username, 'qweqwe')
 
         response = self.app.post(
             route_path('my_account_auth_tokens_add'),
             {'description': desc, 'lifetime': lifetime,
              'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Auth token successfully created')
 
         response = response.follow()
         user = User.get(user_id)
         for auth_token in user.auth_tokens:
             response.mustcontain(auth_token[:4])
 
     def test_my_account_delete_auth_token(self, user_util):
         user = user_util.create_user(password='qweqwe')
         user_id = user.user_id
         self.log_user(user.username, 'qweqwe')
 
         user = User.get(user_id)
         keys = user.get_auth_tokens()
         assert 2 == len(keys)
 
         response = self.app.post(
             route_path('my_account_auth_tokens_add'),
             {'description': 'desc', 'lifetime': -1,
              'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Auth token successfully created')
         response.follow()
 
         user = User.get(user_id)
         keys = user.get_auth_tokens()
         assert 3 == len(keys)
 
         response = self.app.post(
             route_path('my_account_auth_tokens_delete'),
             {'del_auth_token': keys[0].user_api_key_id, 'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Auth token successfully deleted')
 
         user = User.get(user_id)
         keys = user.auth_tokens
         assert 2 == len(keys)

rhodecode/apps/my_account/tests/test_my_account_edit.py

@@ -1,208 +1,190 b''
 # Copyright (C) 2016-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/
 
 
 # Copyright (C) 2016-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.tests import TestController, assert_session_flash
-from rhodecode.lib import helpers as h
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'my_account_edit': ADMIN_PREFIX + '/my_account/edit',
-        'my_account_update': ADMIN_PREFIX + '/my_account/update',
-        'my_account_pullrequests': ADMIN_PREFIX + '/my_account/pull_requests',
-        'my_account_pullrequests_data': ADMIN_PREFIX + '/my_account/pull_requests/data',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests.routes import route_path
 
 
 class TestMyAccountEdit(TestController):
 
     def test_my_account_edit(self):
         self.log_user()
         response = self.app.get(route_path('my_account_edit'))
 
         response.mustcontain('value="test_admin')
 
     @pytest.mark.backends("git", "hg")
     def test_my_account_my_pullrequests(self, pr_util):
         self.log_user()
         response = self.app.get(route_path('my_account_pullrequests'))
         response.mustcontain('There are currently no open pull '
                              'requests requiring your participation.')
 
     @pytest.mark.backends("git", "hg")
     @pytest.mark.parametrize('params, expected_title', [
         ({'closed': 1}, 'Closed'),
         ({'awaiting_my_review': 1}, 'Awaiting my review'),
     ])
     def test_my_account_my_pullrequests_data(self, pr_util, xhr_header, params, expected_title):
         self.log_user()
         response = self.app.get(route_path('my_account_pullrequests_data'),
                                 extra_environ=xhr_header)
         assert response.json == {
             'data': [], 'draw': None,
             'recordsFiltered': 0, 'recordsTotal': 0}
 
         pr = pr_util.create_pull_request(title='TestMyAccountPR')
         expected = {
             'author_raw': 'RhodeCode Admin',
             'name_raw': pr.pull_request_id
         }
         response = self.app.get(route_path('my_account_pullrequests_data'),
                                 extra_environ=xhr_header)
         assert response.json['recordsTotal'] == 1
         assert response.json['data'][0]['author_raw'] == expected['author_raw']
 
         assert response.json['data'][0]['author_raw'] == expected['author_raw']
         assert response.json['data'][0]['name_raw'] == expected['name_raw']
 
     @pytest.mark.parametrize(
         "name, attrs", [
             ('firstname', {'firstname': 'new_username'}),
             ('lastname', {'lastname': 'new_username'}),
             ('admin', {'admin': True}),
             ('admin', {'admin': False}),
             ('extern_type', {'extern_type': 'ldap'}),
             ('extern_type', {'extern_type': None}),
             # ('extern_name', {'extern_name': 'test'}),
             # ('extern_name', {'extern_name': None}),
             ('active', {'active': False}),
             ('active', {'active': True}),
             ('email', {'email': '[e-mail]'}),
         ])
     def test_my_account_update(self, name, attrs, user_util):
         usr = user_util.create_user(password='qweqwe')
         params = usr.get_api_data()  # current user data
         user_id = usr.user_id
         self.log_user(
             username=usr.username, password='qweqwe')
 
         params.update({'password_confirmation': ''})
         params.update({'new_password': ''})
         params.update({'extern_type': 'rhodecode'})
         params.update({'extern_name': 'rhodecode'})
         params.update({'csrf_token': self.csrf_token})
 
         params.update(attrs)
         # my account page cannot set language param yet, only for admins
         del params['language']
         if name == 'email':
             uem = user_util.create_additional_user_email(usr, attrs['email'])
             email_before = User.get(user_id).email
 
         response = self.app.post(route_path('my_account_update'), params)
 
         assert_session_flash(
             response, 'Your account was updated successfully')
 
         del params['csrf_token']
 
         updated_user = User.get(user_id)
         updated_params = updated_user.get_api_data()
         updated_params.update({'password_confirmation': ''})
         updated_params.update({'new_password': ''})
 
         params['last_login'] = updated_params['last_login']
         params['last_activity'] = updated_params['last_activity']
         # my account page cannot set language param yet, only for admins
         # but we get this info from API anyway
         params['language'] = updated_params['language']
 
         if name == 'email':
             params['emails'] = [attrs['email'], email_before]
         if name == 'extern_type':
             # cannot update this via form, expected value is original one
             params['extern_type'] = "rhodecode"
         if name == 'extern_name':
             # cannot update this via form, expected value is original one
             params['extern_name'] = str(user_id)
         if name == 'active':
             # my account cannot deactivate account
             params['active'] = True
         if name == 'admin':
             # my account cannot make you an admin !
             params['admin'] = False
 
         assert params == updated_params
 
     def test_my_account_update_err_email_not_exists_in_emails(self):
         self.log_user()
 
         new_email = '[e-mail]'  # not in emails
         params = {
             'username': 'test_admin',
             'new_password': 'test12',
             'password_confirmation': 'test122',
             'firstname': 'NewName',
             'lastname': 'NewLastname',
             'email': new_email,
             'csrf_token': self.csrf_token,
         }
 
         response = self.app.post(route_path('my_account_update'),
                                  params=params)
 
         response.mustcontain('"[e-mail]" is not one of [e-mail]')
 
     def test_my_account_update_bad_email_address(self):
         self.log_user('test_regular2', 'test12')
 
         new_email = 'newmail.pl'
         params = {
             'username': 'test_admin',
             'new_password': 'test12',
             'password_confirmation': 'test122',
             'firstname': 'NewName',
             'lastname': 'NewLastname',
             'email': new_email,
             'csrf_token': self.csrf_token,
         }
         response = self.app.post(route_path('my_account_update'),
                                  params=params)
 
         response.mustcontain('"newmail.pl" is not one of [e-mail]')

rhodecode/apps/my_account/tests/test_my_account_emails.py

@@ -1,75 +1,66 b''
 # 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.apps._base import ADMIN_PREFIX
 from rhodecode.model.db import User, UserEmailMap
 from rhodecode.tests import (
     TestController, TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_EMAIL,
     assert_session_flash, TEST_USER_REGULAR_PASS)
 from rhodecode.tests.fixture import Fixture
-
-fixture = Fixture()
+from rhodecode.tests.routes import route_path
 
 
-def route_path(name, **kwargs):
-    return {
-        'my_account_emails':
-            ADMIN_PREFIX + '/my_account/emails',
-        'my_account_emails_add':
-            ADMIN_PREFIX + '/my_account/emails/new',
-        'my_account_emails_delete':
-            ADMIN_PREFIX + '/my_account/emails/delete',
-    }[name].format(**kwargs)
+fixture = Fixture()
 
 
 class TestMyAccountEmails(TestController):
     def test_my_account_my_emails(self):
         self.log_user()
         response = self.app.get(route_path('my_account_emails'))
         response.mustcontain('No additional emails specified')
 
     def test_my_account_my_emails_add_remove(self):
         self.log_user()
         response = self.app.get(route_path('my_account_emails'))
         response.mustcontain('No additional emails specified')
 
         response = self.app.post(route_path('my_account_emails_add'),
                                  {'email': '[e-mail]',
                                   'current_password': TEST_USER_REGULAR_PASS,
                                   'csrf_token': self.csrf_token})
 
         response = self.app.get(route_path('my_account_emails'))
 
         email_id = UserEmailMap.query().filter(
             UserEmailMap.user == User.get_by_username(
                 TEST_USER_ADMIN_LOGIN)).filter(
             UserEmailMap.email == '[e-mail]').one().email_id
 
         response.mustcontain('[e-mail]')
         response.mustcontain('<input id="del_email_id" name="del_email_id" '
                              'type="hidden" value="%s" />' % email_id)
 
         response = self.app.post(
             route_path('my_account_emails_delete'), {
                 'del_email_id': email_id,
                 'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Email successfully deleted')
         response = self.app.get(route_path('my_account_emails'))
         response.mustcontain('No additional emails specified')

rhodecode/apps/my_account/tests/test_my_account_notifications.py

@@ -1,207 +1,186 b''
 # 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.apps._base import ADMIN_PREFIX
 from rhodecode.tests import (
     TestController, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,
     TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
 from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
 
 from rhodecode.model.db import Notification, User
-from rhodecode.model.user import UserModel
 from rhodecode.model.notification import NotificationModel
 from rhodecode.model.meta import Session
 
 fixture = Fixture()
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'notifications_show_all': ADMIN_PREFIX + '/notifications',
-        'notifications_mark_all_read': ADMIN_PREFIX + '/notifications_mark_all_read',
-        'notifications_show': ADMIN_PREFIX + '/notifications/{notification_id}',
-        'notifications_update': ADMIN_PREFIX + '/notifications/{notification_id}/update',
-        'notifications_delete': ADMIN_PREFIX + '/notifications/{notification_id}/delete',
-
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 class TestNotificationsController(TestController):
 
     def teardown_method(self, method):
         for n in Notification.query().all():
             inst = Notification.get(n.notification_id)
             Session().delete(inst)
         Session().commit()
 
     def test_mark_all_read(self, user_util):
         user = user_util.create_user(password='qweqwe')
         self.log_user(user.username, 'qweqwe')
 
         self.app.post(
             route_path('notifications_mark_all_read'), status=302,
             params={'csrf_token': self.csrf_token}
         )
 
     def test_show_all(self, user_util):
         user = user_util.create_user(password='qweqwe')
         user_id = user.user_id
         self.log_user(user.username, 'qweqwe')
 
         response = self.app.get(
             route_path('notifications_show_all', params={'type': 'all'}))
         response.mustcontain(
             '<div class="table">No notifications here yet</div>')
 
         notification = NotificationModel().create(
             created_by=user_id, notification_subject=u'test_notification_1',
             notification_body=u'notification_1', recipients=[user_id])
         Session().commit()
         notification_id = notification.notification_id
 
         response = self.app.get(route_path('notifications_show_all',
                                            params={'type': 'all'}))
         response.mustcontain('id="notification_%s"' % notification_id)
 
     def test_show_unread(self, user_util):
         user = user_util.create_user(password='qweqwe')
         user_id = user.user_id
         self.log_user(user.username, 'qweqwe')
 
         response = self.app.get(route_path('notifications_show_all'))
         response.mustcontain(
             '<div class="table">No notifications here yet</div>')
 
         notification = NotificationModel().create(
             created_by=user_id, notification_subject=u'test_notification_1',
             notification_body=u'notification_1', recipients=[user_id])
 
         # mark the USER notification as unread
         user_notification = NotificationModel().get_user_notification(
             user_id, notification)
         user_notification.read = False
 
         Session().commit()
         notification_id = notification.notification_id
 
         response = self.app.get(route_path('notifications_show_all'))
         response.mustcontain('id="notification_%s"' % notification_id)
         response.mustcontain('<div class="desc unread')
 
     @pytest.mark.parametrize('user,password', [
         (TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS),
         (TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS),
     ])
     def test_delete(self, user, password, user_util):
         self.log_user(user, password)
         cur_user = self._get_logged_user()
 
         u1 = user_util.create_user()
         u2 = user_util.create_user()
 
         # make notifications
         notification = NotificationModel().create(
             created_by=cur_user, notification_subject=u'test',
             notification_body=u'hi there', recipients=[cur_user, u1, u2])
         Session().commit()
         u1 = User.get(u1.user_id)
         u2 = User.get(u2.user_id)
 
         # check DB
         def get_notif(un):
             return [x.notification for x in un]
         assert get_notif(cur_user.notifications) == [notification]
         assert get_notif(u1.notifications) == [notification]
         assert get_notif(u2.notifications) == [notification]
         cur_usr_id = cur_user.user_id
 
         response = self.app.post(
             route_path('notifications_delete',
                        notification_id=notification.notification_id),
             params={'csrf_token': self.csrf_token})
         assert response.json == 'ok'
 
         cur_user = User.get(cur_usr_id)
         assert cur_user.notifications == []
 
     @pytest.mark.parametrize('user,password', [
         (TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS),
         (TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS),
     ])
     def test_show(self, user, password, user_util):
         self.log_user(user, password)
         cur_user = self._get_logged_user()
         u1 = user_util.create_user()
         u2 = user_util.create_user()
 
         subject = u'test'
         notif_body = u'hi there'
         notification = NotificationModel().create(
             created_by=cur_user, notification_subject=subject,
             notification_body=notif_body, recipients=[cur_user, u1, u2])
         Session().commit()
 
         response = self.app.get(
             route_path('notifications_show',
                        notification_id=notification.notification_id))
 
         response.mustcontain(subject)
         response.mustcontain(notif_body)
 
     @pytest.mark.parametrize('user,password', [
         (TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS),
         (TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS),
     ])
     def test_update(self, user, password, user_util):
         self.log_user(user, password)
         cur_user = self._get_logged_user()
         u1 = user_util.create_user()
         u2 = user_util.create_user()
 
         # make notifications
         recipients = [cur_user, u1, u2]
         notification = NotificationModel().create(
             created_by=cur_user, notification_subject=u'test',
             notification_body=u'hi there', recipients=recipients)
         Session().commit()
 
         for u_obj in recipients:
             # if it's current user, he has his message already read
             read = u_obj.username == user
             assert len(u_obj.notifications) == 1
             assert u_obj.notifications[0].read == read
 
         response = self.app.post(
             route_path('notifications_update',
                        notification_id=notification.notification_id),
             params={'csrf_token': self.csrf_token})
         assert response.json == 'ok'
 
         cur_user = self._get_logged_user()
         assert True is cur_user.notifications[0].read

rhodecode/apps/my_account/tests/test_my_account_password.py

@@ -1,143 +1,134 b''
 
 # 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 mock
 
 from rhodecode.apps._base import ADMIN_PREFIX
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import check_password
 from rhodecode.model.meta import Session
 from rhodecode.model.user import UserModel
 from rhodecode.tests import assert_session_flash
 from rhodecode.tests.fixture import Fixture, TestController, error_function
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, **kwargs):
-    return {
-        'home': '/',
-        'my_account_password':
-            ADMIN_PREFIX + '/my_account/password',
-        'my_account_password_update':
-            ADMIN_PREFIX + '/my_account/password/update',
-    }[name].format(**kwargs)
-
-
 test_user_1 = 'testme'
 test_user_1_password = '0jd83nHNS/d23n'
 
 
 class TestMyAccountPassword(TestController):
     def test_valid_change_password(self, user_util):
         new_password = 'my_new_valid_password'
         user = user_util.create_user(password=test_user_1_password)
         self.log_user(user.username, test_user_1_password)
 
         form_data = [
             ('current_password', test_user_1_password),
             ('__start__', 'new_password:mapping'),
             ('new_password', new_password),
             ('new_password-confirm', new_password),
             ('__end__', 'new_password:mapping'),
             ('csrf_token', self.csrf_token),
         ]
         response = self.app.post(
             route_path('my_account_password_update'), form_data).follow()
         assert 'Successfully updated password' in response
 
         # check_password depends on user being in session
         Session().add(user)
         try:
             assert check_password(new_password, user.password)
         finally:
             Session().expunge(user)
 
     @pytest.mark.parametrize('current_pw, new_pw, confirm_pw', [
         ('', 'abcdef123', 'abcdef123'),
         ('wrong_pw', 'abcdef123', 'abcdef123'),
         (test_user_1_password, test_user_1_password, test_user_1_password),
         (test_user_1_password, '', ''),
         (test_user_1_password, 'abcdef123', ''),
         (test_user_1_password, '', 'abcdef123'),
         (test_user_1_password, 'not_the', 'same_pw'),
         (test_user_1_password, 'short', 'short'),
     ])
     def test_invalid_change_password(self, current_pw, new_pw, confirm_pw,
                                      user_util):
         user = user_util.create_user(password=test_user_1_password)
         self.log_user(user.username, test_user_1_password)
 
         form_data = [
             ('current_password', current_pw),
             ('__start__', 'new_password:mapping'),
             ('new_password', new_pw),
             ('new_password-confirm', confirm_pw),
             ('__end__', 'new_password:mapping'),
             ('csrf_token', self.csrf_token),
         ]
         response = self.app.post(
             route_path('my_account_password_update'), form_data)
 
         assert_response = response.assert_response()
         assert assert_response.get_elements('.error-block')
 
     @mock.patch.object(UserModel, 'update_user', error_function)
     def test_invalid_change_password_exception(self, user_util):
         user = user_util.create_user(password=test_user_1_password)
         self.log_user(user.username, test_user_1_password)
 
         form_data = [
             ('current_password', test_user_1_password),
             ('__start__', 'new_password:mapping'),
             ('new_password', '123456'),
             ('new_password-confirm', '123456'),
             ('__end__', 'new_password:mapping'),
             ('csrf_token', self.csrf_token),
         ]
         response = self.app.post(
             route_path('my_account_password_update'), form_data)
         assert_session_flash(
             response, 'Error occurred during update of user password')
 
     def test_password_is_updated_in_session_on_password_change(self, user_util):
         old_password = 'abcdef123'
         new_password = 'abcdef124'
 
         user = user_util.create_user(password=old_password)
         session = self.log_user(user.username, old_password)
         old_password_hash = session['password']
 
         form_data = [
             ('current_password', old_password),
             ('__start__', 'new_password:mapping'),
             ('new_password', new_password),
             ('new_password-confirm', new_password),
             ('__end__', 'new_password:mapping'),
             ('csrf_token', self.csrf_token),
         ]
         self.app.post(
             route_path('my_account_password_update'), form_data)
 
         response = self.app.get(route_path('home'))
         session = response.get_session_from_response()
         new_password_hash = session['rhodecode_user']['password']
 
         assert old_password_hash != new_password_hash
  No newline at end of file

rhodecode/apps/my_account/tests/test_my_account_profile.py

@@ -1,54 +1,45 b''
 
 # 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.apps._base import ADMIN_PREFIX
 from rhodecode.tests import (
     TestController, TEST_USER_ADMIN_LOGIN,
     TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
 from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, **kwargs):
-    return {
-        'my_account':
-            ADMIN_PREFIX + '/my_account/profile',
-    }[name].format(**kwargs)
-
-
 class TestMyAccountProfile(TestController):
 
     def test_my_account(self):
         self.log_user()
         response = self.app.get(route_path('my_account'))
 
         response.mustcontain(TEST_USER_ADMIN_LOGIN)
         response.mustcontain('href="/_admin/my_account/edit"')
         response.mustcontain('Photo')
 
     def test_my_account_regular_user(self):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         response = self.app.get(route_path('my_account'))
 
         response.mustcontain(TEST_USER_REGULAR_LOGIN)
         response.mustcontain('href="/_admin/my_account/edit"')
         response.mustcontain('Photo')

rhodecode/apps/my_account/tests/test_my_account_simple_views.py

@@ -1,74 +1,57 b''
 
 # 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.apps._base import ADMIN_PREFIX
-from rhodecode.model.db import User, UserEmailMap, Repository, UserFollowing
-from rhodecode.tests import (
-    TestController, TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_EMAIL,
-    assert_session_flash)
+from rhodecode.model.db import User, Repository, UserFollowing
+from rhodecode.tests import TestController, TEST_USER_ADMIN_LOGIN
 from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, **kwargs):
-    return {
-        'my_account_repos':
-            ADMIN_PREFIX + '/my_account/repos',
-        'my_account_watched':
-            ADMIN_PREFIX + '/my_account/watched',
-        'my_account_perms':
-            ADMIN_PREFIX + '/my_account/perms',
-        'my_account_notifications':
-            ADMIN_PREFIX + '/my_account/notifications',
-    }[name].format(**kwargs)
-
-
 class TestMyAccountSimpleViews(TestController):
 
     def test_my_account_my_repos(self, autologin_user):
         response = self.app.get(route_path('my_account_repos'))
         repos = Repository.query().filter(
             Repository.user == User.get_by_username(
                 TEST_USER_ADMIN_LOGIN)).all()
         for repo in repos:
             response.mustcontain(f'"name_raw":"{repo.repo_name}"')
 
     def test_my_account_my_watched(self, autologin_user):
         response = self.app.get(route_path('my_account_watched'))
 
         repos = UserFollowing.query().filter(
             UserFollowing.user == User.get_by_username(
                 TEST_USER_ADMIN_LOGIN)).all()
         for repo in repos:
             response.mustcontain(f'"name_raw":"{repo.follows_repository.repo_name}"')
 
     def test_my_account_perms(self, autologin_user):
         response = self.app.get(route_path('my_account_perms'))
         assert_response = response.assert_response()
         assert assert_response.get_elements('.perm_tag.none')
         assert assert_response.get_elements('.perm_tag.read')
         assert assert_response.get_elements('.perm_tag.write')
         assert assert_response.get_elements('.perm_tag.admin')
 
     def test_my_account_notifications(self, autologin_user):
         response = self.app.get(route_path('my_account_notifications'))
         response.mustcontain('Test flash message')

rhodecode/apps/my_account/tests/test_my_account_ssh_keys.py

@@ -1,164 +1,142 b''
 
 # 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, UserSshKeys
 
 from rhodecode.tests import TestController, assert_session_flash
 from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-    from rhodecode.apps._base import ADMIN_PREFIX
-
-    base_url = {
-        'my_account_ssh_keys':
-            ADMIN_PREFIX + '/my_account/ssh_keys',
-        'my_account_ssh_keys_generate':
-            ADMIN_PREFIX + '/my_account/ssh_keys/generate',
-        'my_account_ssh_keys_add':
-            ADMIN_PREFIX + '/my_account/ssh_keys/new',
-        'my_account_ssh_keys_delete':
-            ADMIN_PREFIX + '/my_account/ssh_keys/delete',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 class TestMyAccountSshKeysView(TestController):
     INVALID_KEY = """\
             ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDk+77sjDzVeB6vevJsuZds1iNU5
             LANOa5CU5G/9JYIA6RYsWWMO7mbsR82IUckdqOHmxSykfR1D1TdluyIpQLrwgH5kb
             n8FkVI8zBMCKakxowvN67B0R7b1BT4PPzW2JlOXei/m9W12ZY484VTow6/B+kf2Q8
             cP8tmCJmKWZma5Em7OTUhvjyQVNz3v7HfeY5Hq0Ci4ECJ59hepFDabJvtAXg9XrI6
             jvdphZTc30I4fG8+hBHzpeFxUGvSGNtXPUbwaAY8j/oHYrTpMgkj6pUEFsiKfC5zP
             qPFR5HyKTCHW0nFUJnZsbyFT5hMiF/hZkJc9A0ZbdSvJwCRQ/g3bmdL 
             [e-mail]      
         """
     VALID_KEY = 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDk+77sjDzVeB6vev' \
                    'JsuZds1iNU5LANOa5CU5G/9JYIA6RYsWWMO7mbsR82IUckdqOHmxSy' \
                    'kfR1D1TdluyIpQLrwgH5kbn8FkVI8zBMCKakxowvN67B0R7b1BT4PP' \
                    'zW2JlOXei/m9W12ZY484VTow6/B+kf2Q8cP8tmCJmKWZma5Em7OTUh' \
                    'vjyQVNz3v7HfeY5Hq0Ci4ECJ59hepFDabJvtAXg9XrI6jvdphZTc30' \
                    'I4fG8+hBHzpeFxUGvSGNtXPUbwaAY8j/oHYrTpMgkj6pUEFsiKfC5zPq' \
                    'PFR5HyKTCHW0nFUJnZsbyFT5hMiF/hZkJc9A0ZbdSvJwCRQ/g3bmdL ' \
                    '[e-mail]'
     FINGERPRINT = 'MD5:01:4f:ad:29:22:6e:01:37:c9:d2:52:26:52:b0:2d:93'
 
     def test_add_ssh_key_error(self, user_util):
         user = user_util.create_user(password='qweqwe')
         self.log_user(user.username, 'qweqwe')
 
         key_data = self.INVALID_KEY
 
         desc = 'MY SSH KEY'
         response = self.app.post(
             route_path('my_account_ssh_keys_add'),
             {'description': desc, 'key_data': key_data,
              'csrf_token': self.csrf_token})
         assert_session_flash(response, 'An error occurred during ssh '
                                        'key saving: Unable to decode the key')
 
     def test_ssh_key_duplicate(self, user_util):
         user = user_util.create_user(password='qweqwe')
         self.log_user(user.username, 'qweqwe')
         key_data = self.VALID_KEY
 
         desc = 'MY SSH KEY'
         response = self.app.post(
             route_path('my_account_ssh_keys_add'),
             {'description': desc, 'key_data': key_data,
              'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Ssh Key successfully created')
         response.follow()  # flush session flash
 
         # add the same key AGAIN
         desc = 'MY SSH KEY'
         response = self.app.post(
             route_path('my_account_ssh_keys_add'),
             {'description': desc, 'key_data': key_data,
              'csrf_token': self.csrf_token})
 
         err = 'Such key with fingerprint `{}` already exists, ' \
               'please use a different one'.format(self.FINGERPRINT)
         assert_session_flash(response, 'An error occurred during ssh key '
                                        'saving: {}'.format(err))
 
     def test_add_ssh_key(self, user_util):
         user = user_util.create_user(password='qweqwe')
         self.log_user(user.username, 'qweqwe')
 
         key_data = self.VALID_KEY
 
         desc = 'MY SSH KEY'
         response = self.app.post(
             route_path('my_account_ssh_keys_add'),
             {'description': desc, 'key_data': key_data,
              'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Ssh Key successfully created')
 
         response = response.follow()
         response.mustcontain(desc)
 
     def test_delete_ssh_key(self, user_util):
         user = user_util.create_user(password='qweqwe')
         user_id = user.user_id
         self.log_user(user.username, 'qweqwe')
 
         key_data = self.VALID_KEY
 
         desc = 'MY SSH KEY'
         response = self.app.post(
             route_path('my_account_ssh_keys_add'),
             {'description': desc, 'key_data': key_data,
              'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Ssh Key successfully created')
         response = response.follow()  # flush the Session flash
 
         # now delete our key
         keys = UserSshKeys.query().filter(UserSshKeys.user_id == user_id).all()
         assert 1 == len(keys)
 
         response = self.app.post(
             route_path('my_account_ssh_keys_delete'),
             {'del_ssh_key': keys[0].ssh_key_id,
              'csrf_token': self.csrf_token})
 
         assert_session_flash(response, 'Ssh key successfully deleted')
         keys = UserSshKeys.query().filter(UserSshKeys.user_id == user_id).all()
         assert 0 == len(keys)
 
     def test_generate_keypair(self, user_util):
         user = user_util.create_user(password='qweqwe')
         self.log_user(user.username, 'qweqwe')
 
         response = self.app.get(
             route_path('my_account_ssh_keys_generate'))
 
         response.mustcontain('Private key')
         response.mustcontain('Public key')
         response.mustcontain('-----BEGIN PRIVATE KEY-----')

rhodecode/apps/repo_group/tests/test_repo_groups_advanced.py

@@ -1,89 +1,73 b''
 # 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 assert_session_flash
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'edit_repo_group_advanced':
-            '/{repo_group_name}/_settings/advanced',
-        'edit_repo_group_advanced_delete':
-            '/{repo_group_name}/_settings/advanced/delete',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests.routes import route_path
 
 
 @pytest.mark.usefixtures("app")
 class TestRepoGroupsAdvancedView(object):
 
     @pytest.mark.parametrize('repo_group_name', [
         'gro',
         '12345',
     ])
     def test_show_advanced_settings(self, autologin_user, user_util, repo_group_name):
         user_util._test_name = repo_group_name
         gr = user_util.create_repo_group()
         self.app.get(
             route_path('edit_repo_group_advanced',
                        repo_group_name=gr.group_name))
 
     def test_show_advanced_settings_delete(self, autologin_user, user_util,
                                            csrf_token):
         gr = user_util.create_repo_group(auto_cleanup=False)
         repo_group_name = gr.group_name
 
         params = dict(
             csrf_token=csrf_token
         )
         response = self.app.post(
             route_path('edit_repo_group_advanced_delete',
                        repo_group_name=repo_group_name), params=params)
         assert_session_flash(
             response, 'Removed repository group `{}`'.format(repo_group_name))
 
     def test_delete_not_possible_with_objects_inside(self, autologin_user,
                                                      repo_groups, csrf_token):
         zombie_group, parent_group, child_group = repo_groups
 
         response = self.app.get(
             route_path('edit_repo_group_advanced',
                        repo_group_name=parent_group.group_name))
 
         response.mustcontain(
             'This repository group includes 1 children repository group')
 
         params = dict(
             csrf_token=csrf_token
         )
         response = self.app.post(
             route_path('edit_repo_group_advanced_delete',
                        repo_group_name=parent_group.group_name), params=params)
 
         assert_session_flash(
             response, 'This repository group contains 1 subgroup '
                       'and cannot be deleted')

rhodecode/apps/repo_group/tests/test_repo_groups_permissions.py

@@ -1,86 +1,70 b''
 # 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.utils import permission_update_data_generator
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'edit_repo_group_perms':
-            '/{repo_group_name:}/_settings/permissions',
-        'edit_repo_group_perms_update':
-            '/{repo_group_name}/_settings/permissions/update',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests.routes import route_path
 
 
 @pytest.mark.usefixtures("app")
 class TestRepoGroupPermissionsView(object):
 
     def test_edit_perms_view(self, user_util, autologin_user):
         repo_group = user_util.create_repo_group()
 
         self.app.get(
             route_path('edit_repo_group_perms',
                        repo_group_name=repo_group.group_name), status=200)
 
     def test_update_permissions(self, csrf_token, user_util):
         repo_group = user_util.create_repo_group()
         repo_group_name = repo_group.group_name
         user = user_util.create_user()
         user_id = user.user_id
         username = user.username
 
         # grant new
         form_data = permission_update_data_generator(
             csrf_token,
             default='group.write',
             grant=[(user_id, 'group.write', username, 'user')])
 
         # recursive flag required for repo groups
         form_data.extend([('recursive', u'none')])
 
         response = self.app.post(
             route_path('edit_repo_group_perms_update',
                        repo_group_name=repo_group_name), form_data).follow()
 
         assert 'Repository Group permissions updated' in response
 
         # revoke given
         form_data = permission_update_data_generator(
             csrf_token,
             default='group.read',
             revoke=[(user_id, 'user')])
 
         # recursive flag required for repo groups
         form_data.extend([('recursive', u'none')])
 
         response = self.app.post(
             route_path('edit_repo_group_perms_update',
                        repo_group_name=repo_group_name), form_data).follow()
 
         assert 'Repository Group permissions updated' in response

rhodecode/apps/repo_group/tests/test_repo_groups_settings.py

@@ -1,91 +1,78 b''
 
 # 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 assert_session_flash
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
+from rhodecode.tests.routes import route_path
 
-    base_url = {
-        'edit_repo_group': '/{repo_group_name}/_edit',
-        # Update is POST to the above url
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
 
 
 @pytest.mark.usefixtures("app")
 class TestRepoGroupsSettingsView(object):
 
     @pytest.mark.parametrize('repo_group_name', [
         'gro',
         u'12345',
     ])
     def test_edit(self, user_util, autologin_user, repo_group_name):
         user_util._test_name = repo_group_name
         repo_group = user_util.create_repo_group()
 
         self.app.get(
             route_path('edit_repo_group', repo_group_name=repo_group.group_name),
             status=200)
 
     def test_update(self, csrf_token, autologin_user, user_util, rc_fixture):
         repo_group = user_util.create_repo_group()
         repo_group_name = repo_group.group_name
 
         description = 'description for newly created repo group'
         form_data = rc_fixture._get_group_create_params(
             group_name=repo_group.group_name,
             group_description=description,
             csrf_token=csrf_token,
             repo_group_name=repo_group.group_name,
             repo_group_owner=repo_group.user.username)
 
         response = self.app.post(
             route_path('edit_repo_group',
                        repo_group_name=repo_group.group_name),
             form_data,
             status=302)
 
         assert_session_flash(
             response, 'Repository Group `{}` updated successfully'.format(
                 repo_group_name))
 
     def test_update_fails_when_parent_pointing_to_self(
             self, csrf_token, user_util, autologin_user, rc_fixture):
         group = user_util.create_repo_group()
         response = self.app.post(
             route_path('edit_repo_group', repo_group_name=group.group_name),
             rc_fixture._get_group_create_params(
                 repo_group_name=group.group_name,
                 repo_group_owner=group.user.username,
                 repo_group=group.group_id,
                 csrf_token=csrf_token),
             status=200
             )
         response.mustcontain(
             '<span class="error-message">"{}" is not one of -1'.format(
                 group.group_id))

rhodecode/apps/repository/tests/test_pull_requests_list.py

@@ -1,84 +1,69 b''
 # 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
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'pullrequest_show_all': '/{repo_name}/pull-request',
-        'pullrequest_show_all_data': '/{repo_name}/pull-request-data',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests.routes import route_path
 
 
 @pytest.mark.backends("git", "hg")
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestPullRequestList(object):
 
     @pytest.mark.parametrize('params, expected_title', [
         ({'source': 0, 'closed': 1}, 'Closed'),
         ({'source': 0, 'my': 1}, 'Created by me'),
         ({'source': 0, 'awaiting_review': 1}, 'Awaiting review'),
         ({'source': 0, 'awaiting_my_review': 1}, 'Awaiting my review'),
         ({'source': 1}, 'From this repo'),
     ])
     def test_showing_list_page(self, backend, pr_util, params, expected_title):
         pull_request = pr_util.create_pull_request()
 
         response = self.app.get(
             route_path('pullrequest_show_all',
                        repo_name=pull_request.target_repo.repo_name,
                        params=params))
 
         assert_response = response.assert_response()
 
         element = assert_response.get_element('.title .active')
         element_text = element.text_content()
         assert expected_title == element_text
 
     def test_showing_list_page_data(self, backend, pr_util, xhr_header):
         pull_request = pr_util.create_pull_request()
         response = self.app.get(
             route_path('pullrequest_show_all_data',
                        repo_name=pull_request.target_repo.repo_name),
             extra_environ=xhr_header)
 
         assert response.json['recordsTotal'] == 1
         assert response.json['data'][0]['description'] == 'Description'
 
     def test_description_is_escaped_on_index_page(self, backend, pr_util, xhr_header):
         xss_description = "<script>alert('Hi!')</script>"
         pull_request = pr_util.create_pull_request(description=xss_description)
 
         response = self.app.get(
             route_path('pullrequest_show_all_data',
                        repo_name=pull_request.target_repo.repo_name),
             extra_environ=xhr_header)
 
         assert response.json['recordsTotal'] == 1
         assert response.json['data'][0]['description'] == \
                "&lt;script&gt;alert(&#39;Hi!&#39;)&lt;/script&gt;"

rhodecode/apps/repository/tests/test_repo_bookmarks.py

@@ -1,52 +1,40 b''
 # 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
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
+from rhodecode.tests.routes import route_path
 
-    base_url = {
-        'bookmarks_home': '/{repo_name}/bookmarks',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestBookmarks(object):
 
     def test_index(self, backend):
         if backend.alias == 'hg':
             response = self.app.get(
                 route_path('bookmarks_home', repo_name=backend.repo_name))
 
             repo = Repository.get_by_repo_name(backend.repo_name)
             for commit_id, obj_name in repo.scm_instance().bookmarks.items():
                 assert commit_id in response
                 assert obj_name in response
         else:
             self.app.get(
                 route_path('bookmarks_home', repo_name=backend.repo_name),
                 status=404)

rhodecode/apps/repository/tests/test_repo_branches.py

@@ -1,48 +1,35 b''
 # 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
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'branches_home': '/{repo_name}/branches',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests.routes import route_path
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestBranchesController(object):
 
     def test_index(self, backend):
         response = self.app.get(
             route_path('branches_home', repo_name=backend.repo_name))
 
         repo = Repository.get_by_repo_name(backend.repo_name)
 
         for commit_id, obj_name in repo.scm_instance().branches.items():
             assert commit_id in response
             assert obj_name in response

rhodecode/apps/repository/tests/test_repo_changelog.py

@@ -1,219 +1,204 b''
 # 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 re
 
 import pytest
 
 from rhodecode.apps.repository.views.repo_changelog import DEFAULT_CHANGELOG_SIZE
 from rhodecode.tests import TestController
-
-MATCH_HASH = re.compile(r'<span class="commit_hash">r(\d+):[\da-f]+</span>')
+from rhodecode.tests.routes import route_path
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'repo_changelog': '/{repo_name}/changelog',
-        'repo_commits': '/{repo_name}/commits',
-        'repo_commits_file': '/{repo_name}/commits/{commit_id}/{f_path}',
-        'repo_commits_elements': '/{repo_name}/commits_elements',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+MATCH_HASH = re.compile(r'<span class="commit_hash">r(\d+):[\da-f]+</span>')
 
 
 def assert_commits_on_page(response, indexes):
     found_indexes = [int(idx) for idx in MATCH_HASH.findall(response.text)]
     assert found_indexes == indexes
 
 
 class TestChangelogController(TestController):
 
     def test_commits_page(self, backend):
         self.log_user()
         response = self.app.get(
             route_path('repo_commits', repo_name=backend.repo_name))
 
         first_idx = -1
         last_idx = -DEFAULT_CHANGELOG_SIZE
         self.assert_commit_range_on_page(response, first_idx, last_idx, backend)
 
     def test_changelog(self, backend):
         self.log_user()
         response = self.app.get(
             route_path('repo_changelog', repo_name=backend.repo_name))
 
         first_idx = -1
         last_idx = -DEFAULT_CHANGELOG_SIZE
         self.assert_commit_range_on_page(
             response, first_idx, last_idx, backend)
 
     @pytest.mark.backends("hg", "git")
     def test_changelog_filtered_by_branch(self, backend):
         self.log_user()
         self.app.get(
             route_path('repo_changelog', repo_name=backend.repo_name,
                        params=dict(branch=backend.default_branch_name)),
             status=200)
 
     @pytest.mark.backends("hg", "git")
     def test_commits_filtered_by_branch(self, backend):
         self.log_user()
         self.app.get(
             route_path('repo_commits', repo_name=backend.repo_name,
                        params=dict(branch=backend.default_branch_name)),
             status=200)
 
     @pytest.mark.backends("svn")
     def test_changelog_filtered_by_branch_svn(self, autologin_user, backend):
         repo = backend['svn-simple-layout']
         response = self.app.get(
             route_path('repo_changelog', repo_name=repo.repo_name,
                        params=dict(branch='trunk')),
             status=200)
 
         assert_commits_on_page(response, indexes=[15, 12, 7, 3, 2, 1])
 
     def test_commits_filtered_by_wrong_branch(self, backend):
         self.log_user()
         branch = 'wrong-branch-name'
         response = self.app.get(
             route_path('repo_commits', repo_name=backend.repo_name,
                        params=dict(branch=branch)),
             status=302)
         expected_url = '/{repo}/commits/{branch}'.format(
             repo=backend.repo_name, branch=branch)
         assert expected_url in response.location
         response = response.follow()
         expected_warning = f'Branch {branch} is not found.'
         assert expected_warning in response.text
 
     @pytest.mark.xfail_backends("svn", reason="Depends on branch support")
     def test_changelog_filtered_by_branch_with_merges(self, autologin_user, backend):
 
         # Note: The changelog of branch "b" does not contain the commit "a1"
         # although this is a parent of commit "b1". And branch "b" has commits
         # which have a smaller index than commit "a1".
         commits = [
             {'message': 'a'},
             {'message': 'b', 'branch': 'b'},
             {'message': 'a1', 'parents': ['a']},
             {'message': 'b1', 'branch': 'b', 'parents': ['b', 'a1']},
         ]
         backend.create_repo(commits)
 
         self.app.get(
             route_path('repo_changelog', repo_name=backend.repo_name,
                        params=dict(branch='b')),
             status=200)
 
     @pytest.mark.backends("hg")
     def test_commits_closed_branches(self, autologin_user, backend):
         repo = backend['closed_branch']
         response = self.app.get(
             route_path('repo_commits', repo_name=repo.repo_name,
                        params=dict(branch='experimental')),
             status=200)
 
         assert_commits_on_page(response, indexes=[3, 1])
 
     def test_changelog_pagination(self, backend):
         self.log_user()
         # pagination, walk up to page 6
         changelog_url = route_path(
             'repo_commits', repo_name=backend.repo_name)
 
         for page in range(1, 7):
             response = self.app.get(changelog_url, {'page': page})
 
         first_idx = -DEFAULT_CHANGELOG_SIZE * (page - 1) - 1
         last_idx = -DEFAULT_CHANGELOG_SIZE * page
         self.assert_commit_range_on_page(response, first_idx, last_idx, backend)
 
     def assert_commit_range_on_page(
             self, response, first_idx, last_idx, backend):
         input_template = (
             """<input class="commit-range" """ 
             """data-commit-id="%(raw_id)s" data-commit-idx="%(idx)s" """ 
             """data-short-id="%(short_id)s" id="%(raw_id)s" """
             """name="%(raw_id)s" type="checkbox" value="1" />"""
         )
 
         commit_span_template = """<span class="commit_hash">r%s:%s</span>"""
         repo = backend.repo
 
         first_commit_on_page = repo.get_commit(commit_idx=first_idx)
         response.mustcontain(
             input_template % {'raw_id': first_commit_on_page.raw_id,
                               'idx': first_commit_on_page.idx,
                               'short_id': first_commit_on_page.short_id})
 
         response.mustcontain(commit_span_template % (
             first_commit_on_page.idx, first_commit_on_page.short_id)
         )
 
         last_commit_on_page = repo.get_commit(commit_idx=last_idx)
         response.mustcontain(
             input_template % {'raw_id': last_commit_on_page.raw_id,
                               'idx': last_commit_on_page.idx,
                               'short_id': last_commit_on_page.short_id})
         response.mustcontain(commit_span_template % (
             last_commit_on_page.idx, last_commit_on_page.short_id)
         )
 
         first_commit_of_next_page = repo.get_commit(commit_idx=last_idx - 1)
         first_span_of_next_page = commit_span_template % (
             first_commit_of_next_page.idx, first_commit_of_next_page.short_id)
         assert first_span_of_next_page not in response
 
     @pytest.mark.parametrize('test_path', [
         'vcs/exceptions.py',
         '/vcs/exceptions.py',
         '//vcs/exceptions.py'
     ])
     def test_commits_with_filenode(self, backend, test_path):
         self.log_user()
         response = self.app.get(
             route_path('repo_commits_file', repo_name=backend.repo_name,
                        commit_id='tip', f_path=test_path),
             )
 
         # history commits messages
         response.mustcontain('Added exceptions module, this time for real')
         response.mustcontain('Added not implemented hg backend test case')
         response.mustcontain('Added BaseChangeset class')
 
     def test_commits_with_filenode_that_is_dirnode(self, backend):
         self.log_user()
         self.app.get(
             route_path('repo_commits_file', repo_name=backend.repo_name,
                        commit_id='tip', f_path='/tests'),
             status=302)
 
     def test_commits_with_filenode_not_existing(self, backend):
         self.log_user()
         self.app.get(
             route_path('repo_commits_file', repo_name=backend.repo_name,
                        commit_id='tip', f_path='wrong_path'),
             status=302)

rhodecode/apps/repository/tests/test_repo_commit_comments.py

@@ -1,494 +1,477 b''
 # 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 TestController
-
+from rhodecode.tests.routes import route_path
 from rhodecode.model.db import ChangesetComment, Notification
 from rhodecode.model.meta import Session
 from rhodecode.lib import helpers as h
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'repo_commit': '/{repo_name}/changeset/{commit_id}',
-        'repo_commit_comment_create': '/{repo_name}/changeset/{commit_id}/comment/create',
-        'repo_commit_comment_preview': '/{repo_name}/changeset/{commit_id}/comment/preview',
-        'repo_commit_comment_delete': '/{repo_name}/changeset/{commit_id}/comment/{comment_id}/delete',
-        'repo_commit_comment_edit': '/{repo_name}/changeset/{commit_id}/comment/{comment_id}/edit',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
 
 @pytest.mark.backends("git", "hg", "svn")
 class TestRepoCommitCommentsView(TestController):
 
     @pytest.fixture(autouse=True)
     def prepare(self, request, baseapp):
         for x in ChangesetComment.query().all():
             Session().delete(x)
         Session().commit()
 
         for x in Notification.query().all():
             Session().delete(x)
         Session().commit()
 
         request.addfinalizer(self.cleanup)
 
     def cleanup(self):
         for x in ChangesetComment.query().all():
             Session().delete(x)
         Session().commit()
 
         for x in Notification.query().all():
             Session().delete(x)
         Session().commit()
 
     @pytest.mark.parametrize('comment_type', ChangesetComment.COMMENT_TYPES)
     def test_create(self, comment_type, backend):
         self.log_user()
         commit = backend.repo.get_commit('300')
         commit_id = commit.raw_id
         text = 'CommentOnCommit'
 
         params = {'text': text, 'csrf_token': self.csrf_token,
                   'comment_type': comment_type}
         self.app.post(
             route_path('repo_commit_comment_create',
                        repo_name=backend.repo_name, commit_id=commit_id),
             params=params)
 
         response = self.app.get(
             route_path('repo_commit',
                        repo_name=backend.repo_name, commit_id=commit_id))
 
         # test DB
         assert ChangesetComment.query().count() == 1
         assert_comment_links(response, ChangesetComment.query().count(), 0)
 
         assert Notification.query().count() == 1
         assert ChangesetComment.query().count() == 1
 
         notification = Notification.query().all()[0]
 
         comment_id = ChangesetComment.query().first().comment_id
         assert notification.type_ == Notification.TYPE_CHANGESET_COMMENT
 
         author = notification.created_by_user.username_and_name
         sbj = '@{0} left a {1} on commit `{2}` in the `{3}` repository'.format(
             author, comment_type, h.show_id(commit), backend.repo_name)
         assert sbj == notification.subject
 
         lnk = ('/{0}/changeset/{1}#comment-{2}'.format(
             backend.repo_name, commit_id, comment_id))
         assert lnk in notification.body
 
     @pytest.mark.parametrize('comment_type', ChangesetComment.COMMENT_TYPES)
     def test_create_inline(self, comment_type, backend):
         self.log_user()
         commit = backend.repo.get_commit('300')
         commit_id = commit.raw_id
         text = 'CommentOnCommit'
         f_path = 'vcs/web/simplevcs/views/repository.py'
         line = 'n1'
 
         params = {'text': text, 'f_path': f_path, 'line': line,
                   'comment_type': comment_type,
                   'csrf_token': self.csrf_token}
 
         self.app.post(
             route_path('repo_commit_comment_create',
                        repo_name=backend.repo_name, commit_id=commit_id),
             params=params)
 
         response = self.app.get(
             route_path('repo_commit',
                        repo_name=backend.repo_name, commit_id=commit_id))
 
         # test DB
         assert ChangesetComment.query().count() == 1
         assert_comment_links(response, 0, ChangesetComment.query().count())
 
         if backend.alias == 'svn':
             response.mustcontain(
                 '''data-f-path="vcs/commands/summary.py" '''
                 '''data-anchor-id="c-300-ad05457a43f8"'''
             )
         if backend.alias == 'git':
             response.mustcontain(
                 '''data-f-path="vcs/backends/hg.py" '''
                 '''data-anchor-id="c-883e775e89ea-9c390eb52cd6"'''
             )
 
         if backend.alias == 'hg':
             response.mustcontain(
                 '''data-f-path="vcs/backends/hg.py" '''
                 '''data-anchor-id="c-e58d85a3973b-9c390eb52cd6"'''
             )
 
         assert Notification.query().count() == 1
         assert ChangesetComment.query().count() == 1
 
         notification = Notification.query().all()[0]
         comment = ChangesetComment.query().first()
         assert notification.type_ == Notification.TYPE_CHANGESET_COMMENT
 
         assert comment.revision == commit_id
 
         author = notification.created_by_user.username_and_name
         sbj = '@{0} left a {1} on file `{2}` in commit `{3}` in the `{4}` repository'.format(
             author, comment_type, f_path, h.show_id(commit), backend.repo_name)
 
         assert sbj == notification.subject
 
         lnk = ('/{0}/changeset/{1}#comment-{2}'.format(
             backend.repo_name, commit_id, comment.comment_id))
         assert lnk in notification.body
         assert 'on line n1' in notification.body
 
     def test_create_with_mention(self, backend):
         self.log_user()
 
         commit_id = backend.repo.get_commit('300').raw_id
         text = '@test_regular check CommentOnCommit'
 
         params = {'text': text, 'csrf_token': self.csrf_token}
         self.app.post(
             route_path('repo_commit_comment_create',
                        repo_name=backend.repo_name, commit_id=commit_id),
             params=params)
 
         response = self.app.get(
             route_path('repo_commit',
                        repo_name=backend.repo_name, commit_id=commit_id))
         # test DB
         assert ChangesetComment.query().count() == 1
         assert_comment_links(response, ChangesetComment.query().count(), 0)
 
         notification = Notification.query().one()
 
         assert len(notification.recipients) == 2
         users = [x.username for x in notification.recipients]
 
         # test_regular gets notification by @mention
         assert sorted(users) == ['test_admin', 'test_regular']
 
     def test_create_with_status_change(self, backend):
         self.log_user()
         commit = backend.repo.get_commit('300')
         commit_id = commit.raw_id
         text = 'CommentOnCommit'
         f_path = 'vcs/web/simplevcs/views/repository.py'
         line = 'n1'
 
         params = {'text': text, 'changeset_status': 'approved',
                   'csrf_token': self.csrf_token}
 
         self.app.post(
             route_path(
                 'repo_commit_comment_create',
                 repo_name=backend.repo_name, commit_id=commit_id),
             params=params)
 
         response = self.app.get(
             route_path('repo_commit',
                        repo_name=backend.repo_name, commit_id=commit_id))
 
         # test DB
         assert ChangesetComment.query().count() == 1
         assert_comment_links(response, ChangesetComment.query().count(), 0)
 
         assert Notification.query().count() == 1
         assert ChangesetComment.query().count() == 1
 
         notification = Notification.query().all()[0]
 
         comment_id = ChangesetComment.query().first().comment_id
         assert notification.type_ == Notification.TYPE_CHANGESET_COMMENT
 
         author = notification.created_by_user.username_and_name
         sbj = '[status: Approved] @{0} left a note on commit `{1}` in the `{2}` repository'.format(
             author, h.show_id(commit), backend.repo_name)
         assert sbj == notification.subject
 
         lnk = ('/{0}/changeset/{1}#comment-{2}'.format(
             backend.repo_name, commit_id, comment_id))
         assert lnk in notification.body
 
     def test_delete(self, backend):
         self.log_user()
         commit_id = backend.repo.get_commit('300').raw_id
         text = 'CommentOnCommit'
 
         params = {'text': text, 'csrf_token': self.csrf_token}
         self.app.post(
             route_path(
                 'repo_commit_comment_create',
                 repo_name=backend.repo_name, commit_id=commit_id),
             params=params)
 
         comments = ChangesetComment.query().all()
         assert len(comments) == 1
         comment_id = comments[0].comment_id
 
         self.app.post(
             route_path('repo_commit_comment_delete',
                        repo_name=backend.repo_name,
                        commit_id=commit_id,
                        comment_id=comment_id),
             params={'csrf_token': self.csrf_token})
 
         comments = ChangesetComment.query().all()
         assert len(comments) == 0
 
         response = self.app.get(
             route_path('repo_commit',
                        repo_name=backend.repo_name, commit_id=commit_id))
         assert_comment_links(response, 0, 0)
 
     def test_edit(self, backend):
         self.log_user()
         commit_id = backend.repo.get_commit('300').raw_id
         text = 'CommentOnCommit'
 
         params = {'text': text, 'csrf_token': self.csrf_token}
         self.app.post(
             route_path(
                 'repo_commit_comment_create',
                 repo_name=backend.repo_name, commit_id=commit_id),
             params=params)
 
         comments = ChangesetComment.query().all()
         assert len(comments) == 1
         comment_id = comments[0].comment_id
         test_text = 'test_text'
         self.app.post(
             route_path(
                 'repo_commit_comment_edit',
                 repo_name=backend.repo_name,
                 commit_id=commit_id,
                 comment_id=comment_id,
             ),
             params={
                 'csrf_token': self.csrf_token,
                 'text': test_text,
                 'version': '0',
             })
 
         text_form_db = ChangesetComment.query().filter(
             ChangesetComment.comment_id == comment_id).first().text
         assert test_text == text_form_db
 
     def test_edit_without_change(self, backend):
         self.log_user()
         commit_id = backend.repo.get_commit('300').raw_id
         text = 'CommentOnCommit'
 
         params = {'text': text, 'csrf_token': self.csrf_token}
         self.app.post(
             route_path(
                 'repo_commit_comment_create',
                 repo_name=backend.repo_name, commit_id=commit_id),
             params=params)
 
         comments = ChangesetComment.query().all()
         assert len(comments) == 1
         comment_id = comments[0].comment_id
 
         response = self.app.post(
             route_path(
                 'repo_commit_comment_edit',
                 repo_name=backend.repo_name,
                 commit_id=commit_id,
                 comment_id=comment_id,
             ),
             params={
                 'csrf_token': self.csrf_token,
                 'text': text,
                 'version': '0',
             },
             status=404,
         )
         assert response.status_int == 404
 
     def test_edit_try_edit_already_edited(self, backend):
         self.log_user()
         commit_id = backend.repo.get_commit('300').raw_id
         text = 'CommentOnCommit'
 
         params = {'text': text, 'csrf_token': self.csrf_token}
         self.app.post(
             route_path(
                 'repo_commit_comment_create',
                 repo_name=backend.repo_name, commit_id=commit_id
             ),
             params=params,
         )
 
         comments = ChangesetComment.query().all()
         assert len(comments) == 1
         comment_id = comments[0].comment_id
         test_text = 'test_text'
         self.app.post(
             route_path(
                 'repo_commit_comment_edit',
                 repo_name=backend.repo_name,
                 commit_id=commit_id,
                 comment_id=comment_id,
             ),
             params={
                 'csrf_token': self.csrf_token,
                 'text': test_text,
                 'version': '0',
             }
         )
         test_text_v2 = 'test_v2'
         response = self.app.post(
             route_path(
                 'repo_commit_comment_edit',
                 repo_name=backend.repo_name,
                 commit_id=commit_id,
                 comment_id=comment_id,
             ),
             params={
                 'csrf_token': self.csrf_token,
                 'text': test_text_v2,
                 'version': '0',
             },
             status=409,
         )
         assert response.status_int == 409
 
         text_form_db = ChangesetComment.query().filter(
             ChangesetComment.comment_id == comment_id).first().text
 
         assert test_text == text_form_db
         assert test_text_v2 != text_form_db
 
     def test_edit_forbidden_for_immutable_comments(self, backend):
         self.log_user()
         commit_id = backend.repo.get_commit('300').raw_id
         text = 'CommentOnCommit'
 
         params = {'text': text, 'csrf_token': self.csrf_token, 'version': '0'}
         self.app.post(
             route_path(
                 'repo_commit_comment_create',
                 repo_name=backend.repo_name,
                 commit_id=commit_id,
             ),
             params=params
         )
 
         comments = ChangesetComment.query().all()
         assert len(comments) == 1
         comment_id = comments[0].comment_id
 
         comment = ChangesetComment.get(comment_id)
         comment.immutable_state = ChangesetComment.OP_IMMUTABLE
         Session().add(comment)
         Session().commit()
 
         response = self.app.post(
             route_path(
                 'repo_commit_comment_edit',
                 repo_name=backend.repo_name,
                 commit_id=commit_id,
                 comment_id=comment_id,
             ),
             params={
                 'csrf_token': self.csrf_token,
                 'text': 'test_text',
             },
             status=403,
         )
         assert response.status_int == 403
 
     def test_delete_forbidden_for_immutable_comments(self, backend):
         self.log_user()
         commit_id = backend.repo.get_commit('300').raw_id
         text = 'CommentOnCommit'
 
         params = {'text': text, 'csrf_token': self.csrf_token}
         self.app.post(
             route_path(
                 'repo_commit_comment_create',
                 repo_name=backend.repo_name, commit_id=commit_id),
             params=params)
 
         comments = ChangesetComment.query().all()
         assert len(comments) == 1
         comment_id = comments[0].comment_id
 
         comment = ChangesetComment.get(comment_id)
         comment.immutable_state = ChangesetComment.OP_IMMUTABLE
         Session().add(comment)
         Session().commit()
 
         self.app.post(
             route_path('repo_commit_comment_delete',
                        repo_name=backend.repo_name,
                        commit_id=commit_id,
                        comment_id=comment_id),
             params={'csrf_token': self.csrf_token},
             status=403)
 
     @pytest.mark.parametrize('renderer, text_input, output', [
         ('rst', 'plain text', '<p>plain text</p>'),
         ('rst', 'header\n======', '<h1 class="title">header</h1>'),
         ('rst', '*italics*', '<em>italics</em>'),
         ('rst', '**bold**', '<strong>bold</strong>'),
         ('markdown', 'plain text', '<p>plain text</p>'),
         ('markdown', '# header', '<h1>header</h1>'),
         ('markdown', '*italics*', '<em>italics</em>'),
         ('markdown', '**bold**', '<strong>bold</strong>'),
     ], ids=['rst-plain', 'rst-header', 'rst-italics', 'rst-bold', 'md-plain',
             'md-header', 'md-italics', 'md-bold', ])
     def test_preview(self, renderer, text_input, output, backend, xhr_header):
         self.log_user()
         params = {
             'renderer': renderer,
             'text': text_input,
             'csrf_token': self.csrf_token
         }
         commit_id = '0' * 16  # fake this for tests
         response = self.app.post(
             route_path('repo_commit_comment_preview',
                        repo_name=backend.repo_name, commit_id=commit_id,),
             params=params,
             extra_environ=xhr_header)
 
         response.mustcontain(output)
 
 
 def assert_comment_links(response, comments, inline_comments):
     response.mustcontain(
         '<span class="display-none" id="general-comments-count">{}</span>'.format(comments))
     response.mustcontain(
         '<span class="display-none" id="inline-comments-count">{}</span>'.format(inline_comments))
 
 
 

rhodecode/apps/repository/tests/test_repo_commits.py

@@ -1,336 +1,316 b''
 
 # 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.apps.repository.tests.test_repo_compare import ComparePage
 from rhodecode.lib.helpers import _shorten_commit_id
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'repo_commit': '/{repo_name}/changeset/{commit_id}',
-        'repo_commit_children': '/{repo_name}/changeset_children/{commit_id}',
-        'repo_commit_parents': '/{repo_name}/changeset_parents/{commit_id}',
-        'repo_commit_raw': '/{repo_name}/changeset-diff/{commit_id}',
-        'repo_commit_patch': '/{repo_name}/changeset-patch/{commit_id}',
-        'repo_commit_download': '/{repo_name}/changeset-download/{commit_id}',
-        'repo_commit_data': '/{repo_name}/changeset-data/{commit_id}',
-        'repo_compare': '/{repo_name}/compare/{source_ref_type}@{source_ref}...{target_ref_type}@{target_ref}',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests.routes import route_path
 
 
 @pytest.mark.usefixtures("app")
 class TestRepoCommitView(object):
 
     def test_show_commit(self, backend):
         commit_id = self.commit_id[backend.alias]
         response = self.app.get(route_path(
             'repo_commit', repo_name=backend.repo_name, commit_id=commit_id))
         response.mustcontain('Added a symlink')
         response.mustcontain(commit_id)
         response.mustcontain('No newline at end of file')
 
     def test_show_raw(self, backend):
         commit_id = self.commit_id[backend.alias]
         # webtest uses linter to check if response is bytes,
         # and we use memoryview here as a wrapper, quick turn-off
         self.app.lint = False
 
         response = self.app.get(route_path(
             'repo_commit_raw',
             repo_name=backend.repo_name, commit_id=commit_id))
         assert response.body == self.diffs[backend.alias]
 
     def test_show_raw_patch(self, backend):
         response = self.app.get(route_path(
             'repo_commit_patch', repo_name=backend.repo_name,
             commit_id=self.commit_id[backend.alias]))
         assert response.body == self.patches[backend.alias]
 
     def test_commit_download(self, backend):
         # webtest uses linter to check if response is bytes,
         # and we use memoryview here as a wrapper, quick turn-off
         self.app.lint = False
 
         response = self.app.get(route_path(
             'repo_commit_download',
             repo_name=backend.repo_name,
             commit_id=self.commit_id[backend.alias]))
         assert response.body == self.diffs[backend.alias]
 
     def test_single_commit_page_different_ops(self, backend):
         commit_id = {
             'hg': '603d6c72c46d953420c89d36372f08d9f305f5dd',
             'git': '03fa803d7e9fb14daa9a3089e0d1494eda75d986',
             'svn': '337',
         }
         diff_stat = {
             'hg': (21, 943, 288),
             'git': (20, 941, 286),
             'svn': (21, 943, 288),
         }
 
         commit_id = commit_id[backend.alias]
         response = self.app.get(route_path(
             'repo_commit',
             repo_name=backend.repo_name, commit_id=commit_id))
 
         response.mustcontain(_shorten_commit_id(commit_id))
 
         compare_page = ComparePage(response)
         file_changes = diff_stat[backend.alias]
         compare_page.contains_change_summary(*file_changes)
 
         # files op files
         response.mustcontain('File not present at commit: %s' %
                              _shorten_commit_id(commit_id))
 
         # svn uses a different filename
         if backend.alias == 'svn':
             response.mustcontain('new file 10644')
         else:
             response.mustcontain('new file 100644')
         response.mustcontain('Changed theme to ADC theme')  # commit msg
 
         self._check_new_diff_menus(response, right_menu=True)
 
     def test_commit_range_page_different_ops(self, backend):
         commit_id_range = {
             'hg': (
                 '25d7e49c18b159446cadfa506a5cf8ad1cb04067',
                 '603d6c72c46d953420c89d36372f08d9f305f5dd'),
             'git': (
                 '6fc9270775aaf5544c1deb014f4ddd60c952fcbb',
                 '03fa803d7e9fb14daa9a3089e0d1494eda75d986'),
             'svn': (
                 '335',
                 '337'),
         }
         commit_ids = commit_id_range[backend.alias]
         commit_id = '%s...%s' % (commit_ids[0], commit_ids[1])
         response = self.app.get(route_path(
             'repo_commit',
             repo_name=backend.repo_name, commit_id=commit_id))
 
         response.mustcontain(_shorten_commit_id(commit_ids[0]))
         response.mustcontain(_shorten_commit_id(commit_ids[1]))
 
         compare_page = ComparePage(response)
 
         # svn is special
         if backend.alias == 'svn':
             response.mustcontain('new file 10644')
             for file_changes in [(1, 5, 1), (12, 236, 22), (21, 943, 288)]:
                 compare_page.contains_change_summary(*file_changes)
         elif backend.alias == 'git':
             response.mustcontain('new file 100644')
             for file_changes in [(12, 222, 20), (20, 941, 286)]:
                 compare_page.contains_change_summary(*file_changes)
         else:
             response.mustcontain('new file 100644')
             for file_changes in [(12, 222, 20), (21, 943, 288)]:
                 compare_page.contains_change_summary(*file_changes)
 
         # files op files
         response.mustcontain('File not present at commit: %s' % _shorten_commit_id(commit_ids[1]))
         response.mustcontain('Added docstrings to vcs.cli')  # commit msg
         response.mustcontain('Changed theme to ADC theme')  # commit msg
 
         self._check_new_diff_menus(response)
 
     def test_combined_compare_commit_page_different_ops(self, backend):
         commit_id_range = {
             'hg': (
                 '4fdd71e9427417b2e904e0464c634fdee85ec5a7',
                 '603d6c72c46d953420c89d36372f08d9f305f5dd'),
             'git': (
                 'f5fbf9cfd5f1f1be146f6d3b38bcd791a7480c13',
                 '03fa803d7e9fb14daa9a3089e0d1494eda75d986'),
             'svn': (
                 '335',
                 '337'),
         }
         commit_ids = commit_id_range[backend.alias]
         response = self.app.get(route_path(
             'repo_compare',
             repo_name=backend.repo_name,
             source_ref_type='rev', source_ref=commit_ids[0],
             target_ref_type='rev', target_ref=commit_ids[1], ))
 
         response.mustcontain(_shorten_commit_id(commit_ids[0]))
         response.mustcontain(_shorten_commit_id(commit_ids[1]))
 
         # files op files
         response.mustcontain('File not present at commit: %s' %
                              _shorten_commit_id(commit_ids[1]))
 
         compare_page = ComparePage(response)
 
         # svn is special
         if backend.alias == 'svn':
             response.mustcontain('new file 10644')
             file_changes = (32, 1179, 310)
             compare_page.contains_change_summary(*file_changes)
         elif backend.alias == 'git':
             response.mustcontain('new file 100644')
             file_changes = (31, 1163, 306)
             compare_page.contains_change_summary(*file_changes)
         else:
             response.mustcontain('new file 100644')
             file_changes = (32, 1165, 308)
             compare_page.contains_change_summary(*file_changes)
 
         response.mustcontain('Added docstrings to vcs.cli')  # commit msg
         response.mustcontain('Changed theme to ADC theme')  # commit msg
 
         self._check_new_diff_menus(response)
 
     def test_changeset_range(self, backend):
         self._check_changeset_range(
             backend, self.commit_id_range, self.commit_id_range_result)
 
     def test_changeset_range_with_initial_commit(self, backend):
         commit_id_range = {
             'hg': (
                 'b986218ba1c9b0d6a259fac9b050b1724ed8e545'
                 '...6cba7170863a2411822803fa77a0a264f1310b35'),
             'git': (
                 'c1214f7e79e02fc37156ff215cd71275450cffc3'
                 '...fa6600f6848800641328adbf7811fd2372c02ab2'),
             'svn': '1...3',
         }
         commit_id_range_result = {
             'hg': ['b986218ba1c9', '3d8f361e72ab', '6cba7170863a'],
             'git': ['c1214f7e79e0', '38b5fe81f109', 'fa6600f68488'],
             'svn': ['1', '2', '3'],
         }
         self._check_changeset_range(
             backend, commit_id_range, commit_id_range_result)
 
     def _check_changeset_range(
             self, backend, commit_id_ranges, commit_id_range_result):
         response = self.app.get(
             route_path('repo_commit',
                        repo_name=backend.repo_name,
                        commit_id=commit_id_ranges[backend.alias]))
 
         expected_result = commit_id_range_result[backend.alias]
         response.mustcontain('{} commits'.format(len(expected_result)))
         for commit_id in expected_result:
             response.mustcontain(commit_id)
 
     commit_id = {
         'hg': '2062ec7beeeaf9f44a1c25c41479565040b930b2',
         'svn': '393',
         'git': 'fd627b9e0dd80b47be81af07c4a98518244ed2f7',
     }
 
     commit_id_range = {
         'hg': (
             'a53d9201d4bc278910d416d94941b7ea007ecd52'
             '...2062ec7beeeaf9f44a1c25c41479565040b930b2'),
         'git': (
             '7ab37bc680b4aa72c34d07b230c866c28e9fc204'
             '...fd627b9e0dd80b47be81af07c4a98518244ed2f7'),
         'svn': '391...393',
     }
 
     commit_id_range_result = {
         'hg': ['a53d9201d4bc', '96507bd11ecc', '2062ec7beeea'],
         'git': ['7ab37bc680b4', '5f2c6ee19592', 'fd627b9e0dd8'],
         'svn': ['391', '392', '393'],
     }
 
     diffs = {
         'hg': br"""diff --git a/README b/README
 new file mode 120000
 --- /dev/null
 +++ b/README
 @@ -0,0 +1,1 @@
 +README.rst
 \ No newline at end of file
 """,
         'git': br"""diff --git a/README b/README
 new file mode 120000
 index 0000000..92cacd2
 --- /dev/null
 +++ b/README
 @@ -0,0 +1 @@
 +README.rst
 \ No newline at end of file
 """,
         'svn': b"""Index: README
 ===================================================================
 diff --git a/README b/README
 new file mode 10644
 --- /dev/null\t(revision 0)
 +++ b/README\t(revision 393)
 @@ -0,0 +1 @@
 +link README.rst
 \\ No newline at end of file
 """,
     }
 
     patches = {
         'hg': br"""# HG changeset patch
 # User Marcin Kuzminski <[e-mail]>
 # Date 2014-01-07 12:21:40
 # Node ID 2062ec7beeeaf9f44a1c25c41479565040b930b2
 # Parent  96507bd11ecc815ebc6270fdf6db110928c09c1e
 
 Added a symlink
 
 """ + diffs['hg'],
         'git': br"""From fd627b9e0dd80b47be81af07c4a98518244ed2f7 2014-01-07 12:22:20
 From: Marcin Kuzminski <[e-mail]>
 Date: 2014-01-07 12:22:20
 Subject: [PATCH] Added a symlink
 
 ---
 
 """ + diffs['git'],
         'svn': br"""# SVN changeset patch
 # User marcin
 # Date 2014-09-02 12:25:22.071142
 # Revision 393
 
 Added a symlink
 
 """ + diffs['svn'],
     }
 
     def _check_new_diff_menus(self, response, right_menu=False,):
         # individual file diff menus
         for elem in ['Show file before', 'Show file after']:
             response.mustcontain(elem)
 
         # right pane diff menus
         if right_menu:
             for elem in ['Hide whitespace changes', 'Toggle wide diff',
                          'Show full context diff']:
                 response.mustcontain(elem)

rhodecode/apps/repository/tests/test_repo_compare.py

@@ -1,670 +1,656 b''
 
 # 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
 import lxml.html
 
 from rhodecode.lib.vcs.exceptions import RepositoryRequirementError
 from rhodecode.tests import assert_session_flash
 from rhodecode.tests.utils import AssertResponse, commit_change
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'repo_compare_select': '/{repo_name}/compare',
-        'repo_compare': '/{repo_name}/compare/{source_ref_type}@{source_ref}...{target_ref_type}@{target_ref}',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests.routes import route_path
 
 
 @pytest.mark.usefixtures("autologin_user", "app")
 class TestCompareView(object):
 
     def test_compare_index_is_reached_at_least_once(self, backend):
         repo = backend.repo
         self.app.get(
             route_path('repo_compare_select', repo_name=repo.repo_name))
 
     @pytest.mark.xfail_backends("svn", reason="Requires pull")
     def test_compare_remote_with_different_commit_indexes(self, backend):
         # Preparing the following repository structure:
         #
         # Origin repository has two commits:
         #
         #    0    1
         #    A -- D
         #
         # The fork of it has a few more commits and "D" has a commit index
         # which does not exist in origin.
         #
         #    0    1    2    3    4
         #    A --   --   -- D -- E
         #      \- B -- C
         #
 
         fork = backend.create_repo()
         origin = backend.create_repo()
 
         # prepare fork
         commit0 = commit_change(
             fork.repo_name, filename=b'file1', content=b'A',
             message='A - Initial Commit', vcs_type=backend.alias, parent=None, newfile=True)
 
         commit1 = commit_change(
             fork.repo_name, filename=b'file1', content=b'B',
             message='B, child of A', vcs_type=backend.alias, parent=commit0)
 
         commit_change(  # commit 2
             fork.repo_name, filename=b'file1', content=b'C',
             message='C, child of B', vcs_type=backend.alias, parent=commit1)
 
         commit3 = commit_change(
             fork.repo_name, filename=b'file1', content=b'D',
             message='D, child of A', vcs_type=backend.alias, parent=commit0)
 
         commit4 = commit_change(
             fork.repo_name, filename=b'file1', content=b'E',
             message='E, child of D', vcs_type=backend.alias, parent=commit3)
 
         # prepare origin repository, taking just the history up to D
 
         origin_repo = origin.scm_instance(cache=False)
         origin_repo.config.clear_section('hooks')
         origin_repo.pull(fork.repo_full_path, commit_ids=[commit3.raw_id])
         origin_repo = origin.scm_instance(cache=False)  # cache rebuild
 
         # Verify test fixture setup
         # This does not work for git
         if backend.alias != 'git':
             assert 5 == len(fork.scm_instance(cache=False).commit_ids)
             assert 2 == len(origin_repo.commit_ids)
 
         # Comparing the revisions
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=origin.repo_name,
                        source_ref_type="rev", source_ref=commit3.raw_id,
                        target_ref_type="rev", target_ref=commit4.raw_id,
                        params=dict(merge='1', target_repo=fork.repo_name)
                        ),
             status=200)
 
         compare_page = ComparePage(response)
         compare_page.contains_commits([commit4])
 
     @pytest.mark.xfail_backends("svn", reason="Depends on branch support")
     def test_compare_forks_on_branch_extra_commits(self, backend):
         repo1 = backend.create_repo()
 
         # commit something !
         commit0 = commit_change(
             repo1.repo_name, filename=b'file1', content=b'line1\n',
             message='commit1', vcs_type=backend.alias, parent=None,
             newfile=True)
 
         # fork this repo
         repo2 = backend.create_fork()
 
         # add two extra commit into fork
         commit1 = commit_change(
             repo2.repo_name, filename=b'file1', content=b'line1\nline2\n',
             message='commit2', vcs_type=backend.alias, parent=commit0)
 
         commit2 = commit_change(
             repo2.repo_name, filename=b'file1', content=b'line1\nline2\nline3\n',
             message='commit3', vcs_type=backend.alias, parent=commit1)
 
         commit_id1 = repo1.scm_instance().DEFAULT_BRANCH_NAME
         commit_id2 = repo2.scm_instance().DEFAULT_BRANCH_NAME
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=repo1.repo_name,
                        source_ref_type="branch", source_ref=commit_id2,
                        target_ref_type="branch", target_ref=commit_id1,
                        params=dict(merge='1', target_repo=repo2.repo_name)
                        ))
 
         response.mustcontain('%s@%s' % (repo1.repo_name, commit_id2))
         response.mustcontain('%s@%s' % (repo2.repo_name, commit_id1))
 
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 2, 0)
         compare_page.contains_commits([commit1, commit2])
 
         anchor = 'a_c-{}-826e8142e6ba'.format(commit0.short_id)
         compare_page.contains_file_links_and_anchors([('file1', anchor), ])
 
         # Swap is removed when comparing branches since it's a PR feature and
         # it is then a preview mode
         compare_page.swap_is_hidden()
         compare_page.target_source_are_disabled()
 
     @pytest.mark.xfail_backends("svn", reason="Depends on branch support")
-    def test_compare_forks_on_branch_extra_commits_origin_has_incomming(self, backend):
+    def test_compare_forks_on_branch_extra_commits_origin_has_incoming(self, backend):
         repo1 = backend.create_repo()
 
         # commit something !
         commit0 = commit_change(
             repo1.repo_name, filename=b'file1', content=b'line1\n',
             message='commit1', vcs_type=backend.alias, parent=None,
             newfile=True)
 
         # fork this repo
         repo2 = backend.create_fork()
 
         # now commit something to origin repo
         commit_change(
             repo1.repo_name, filename=b'file2', content=b'line1file2\n',
             message='commit2', vcs_type=backend.alias, parent=commit0,
             newfile=True)
 
         # add two extra commit into fork
         commit1 = commit_change(
             repo2.repo_name, filename=b'file1', content=b'line1\nline2\n',
             message='commit2', vcs_type=backend.alias, parent=commit0)
 
         commit2 = commit_change(
             repo2.repo_name, filename=b'file1', content=b'line1\nline2\nline3\n',
             message='commit3', vcs_type=backend.alias, parent=commit1)
 
         commit_id1 = repo1.scm_instance().DEFAULT_BRANCH_NAME
         commit_id2 = repo2.scm_instance().DEFAULT_BRANCH_NAME
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=repo1.repo_name,
                        source_ref_type="branch", source_ref=commit_id2,
                        target_ref_type="branch", target_ref=commit_id1,
                        params=dict(merge='1', target_repo=repo2.repo_name),
                        ))
 
-        response.mustcontain('%s@%s' % (repo1.repo_name, commit_id2))
-        response.mustcontain('%s@%s' % (repo2.repo_name, commit_id1))
+        response.mustcontain(f'{repo1.repo_name}@{commit_id2}')
+        response.mustcontain(f'{repo2.repo_name}@{commit_id1}')
 
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 2, 0)
         compare_page.contains_commits([commit1, commit2])
-        anchor = 'a_c-{}-826e8142e6ba'.format(commit0.short_id)
+        anchor = f'a_c-{commit0.short_id}-826e8142e6ba'
         compare_page.contains_file_links_and_anchors([('file1', anchor), ])
 
         # Swap is removed when comparing branches since it's a PR feature and
         # it is then a preview mode
         compare_page.swap_is_hidden()
         compare_page.target_source_are_disabled()
 
     @pytest.mark.xfail_backends("svn")
     # TODO(marcink): no svn support for compare two seperate repos
     def test_compare_of_unrelated_forks(self, backend):
         orig = backend.create_repo(number_of_commits=1)
         fork = backend.create_repo(number_of_commits=1)
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=orig.repo_name,
                        source_ref_type="rev", source_ref="tip",
                        target_ref_type="rev", target_ref="tip",
                        params=dict(merge='1', target_repo=fork.repo_name),
                        ),
             status=302)
         response = response.follow()
         response.mustcontain("Repositories unrelated.")
 
     @pytest.mark.xfail_backends("svn")
     def test_compare_cherry_pick_commits_from_bottom(self, backend):
 
         # repo1:
         #     commit0:
         #     commit1:
         # repo1-fork- in which we will cherry pick bottom commits
         #     commit0:
         #     commit1:
         #     commit2: x
         #     commit3: x
         #     commit4: x
         #     commit5:
         # make repo1, and commit1+commit2
 
         repo1 = backend.create_repo()
 
         # commit something !
         commit0 = commit_change(
             repo1.repo_name, filename=b'file1', content=b'line1\n',
             message='commit1', vcs_type=backend.alias, parent=None,
             newfile=True)
         commit1 = commit_change(
             repo1.repo_name, filename=b'file1', content=b'line1\nline2\n',
             message='commit2', vcs_type=backend.alias, parent=commit0)
 
         # fork this repo
         repo2 = backend.create_fork()
 
         # now make commit3-6
         commit2 = commit_change(
             repo1.repo_name, filename=b'file1', content=b'line1\nline2\nline3\n',
             message='commit3', vcs_type=backend.alias, parent=commit1)
         commit3 = commit_change(
             repo1.repo_name, filename=b'file1',content=b'line1\nline2\nline3\nline4\n',
             message='commit4', vcs_type=backend.alias, parent=commit2)
         commit4 = commit_change(
             repo1.repo_name, filename=b'file1', content=b'line1\nline2\nline3\nline4\nline5\n',
             message='commit5', vcs_type=backend.alias, parent=commit3)
         commit_change(  # commit 5
             repo1.repo_name, filename=b'file1', content=b'line1\nline2\nline3\nline4\nline5\nline6\n',
             message='commit6', vcs_type=backend.alias, parent=commit4)
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=repo2.repo_name,
                        # parent of commit2, in target repo2
                        source_ref_type="rev", source_ref=commit1.raw_id,
                        target_ref_type="rev", target_ref=commit4.raw_id,
                        params=dict(merge='1', target_repo=repo1.repo_name),
                        ))
         response.mustcontain('%s@%s' % (repo2.repo_name, commit1.short_id))
         response.mustcontain('%s@%s' % (repo1.repo_name, commit4.short_id))
 
         # files
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 3, 0)
         compare_page.contains_commits([commit2, commit3, commit4])
         anchor = 'a_c-{}-826e8142e6ba'.format(commit1.short_id)
         compare_page.contains_file_links_and_anchors([('file1', anchor),])
 
     @pytest.mark.xfail_backends("svn")
     def test_compare_cherry_pick_commits_from_top(self, backend):
         # repo1:
         #     commit0:
         #     commit1:
         # repo1-fork- in which we will cherry pick bottom commits
         #     commit0:
         #     commit1:
         #     commit2:
         #     commit3: x
         #     commit4: x
         #     commit5: x
 
         # make repo1, and commit1+commit2
         repo1 = backend.create_repo()
 
         # commit something !
         commit0 = commit_change(
             repo1.repo_name, filename=b'file1', content=b'line1\n',
             message='commit1', vcs_type=backend.alias, parent=None,
             newfile=True)
         commit1 = commit_change(
             repo1.repo_name, filename=b'file1', content=b'line1\nline2\n',
             message='commit2', vcs_type=backend.alias, parent=commit0)
 
         # fork this repo
         backend.create_fork()
 
         # now make commit3-6
         commit2 = commit_change(
             repo1.repo_name, filename=b'file1', content=b'line1\nline2\nline3\n',
             message='commit3', vcs_type=backend.alias, parent=commit1)
         commit3 = commit_change(
             repo1.repo_name, filename=b'file1',
             content=b'line1\nline2\nline3\nline4\n', message='commit4',
             vcs_type=backend.alias, parent=commit2)
         commit4 = commit_change(
             repo1.repo_name, filename=b'file1',
             content=b'line1\nline2\nline3\nline4\nline5\n', message='commit5',
             vcs_type=backend.alias, parent=commit3)
         commit5 = commit_change(
             repo1.repo_name, filename=b'file1',
             content=b'line1\nline2\nline3\nline4\nline5\nline6\n',
             message='commit6', vcs_type=backend.alias, parent=commit4)
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=repo1.repo_name,
                        # parent of commit3, not in source repo2
                        source_ref_type="rev", source_ref=commit2.raw_id,
                        target_ref_type="rev", target_ref=commit5.raw_id,
                        params=dict(merge='1'),))
 
         response.mustcontain('%s@%s' % (repo1.repo_name, commit2.short_id))
         response.mustcontain('%s@%s' % (repo1.repo_name, commit5.short_id))
 
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 3, 0)
         compare_page.contains_commits([commit3, commit4, commit5])
 
         # files
         anchor = 'a_c-{}-826e8142e6ba'.format(commit2.short_id)
         compare_page.contains_file_links_and_anchors([('file1', anchor),])
 
     @pytest.mark.xfail_backends("svn")
     def test_compare_remote_branches(self, backend):
         repo1 = backend.repo
         repo2 = backend.create_fork()
 
         commit_id1 = repo1.get_commit(commit_idx=3).raw_id
         commit_id1_short = repo1.get_commit(commit_idx=3).short_id
         commit_id2 = repo1.get_commit(commit_idx=6).raw_id
         commit_id2_short = repo1.get_commit(commit_idx=6).short_id
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=repo1.repo_name,
                        source_ref_type="rev", source_ref=commit_id1,
                        target_ref_type="rev", target_ref=commit_id2,
                        params=dict(merge='1', target_repo=repo2.repo_name),
                        ))
 
         response.mustcontain('%s@%s' % (repo1.repo_name, commit_id1))
         response.mustcontain('%s@%s' % (repo2.repo_name, commit_id2))
 
         compare_page = ComparePage(response)
 
         # outgoing commits between those commits
         compare_page.contains_commits(
             [repo2.get_commit(commit_idx=x) for x in [4, 5, 6]])
 
         # files
         compare_page.contains_file_links_and_anchors([
             ('vcs/backends/hg.py', 'a_c-{}-9c390eb52cd6'.format(commit_id2_short)),
             ('vcs/backends/__init__.py', 'a_c-{}-41b41c1f2796'.format(commit_id1_short)),
             ('vcs/backends/base.py', 'a_c-{}-2f574d260608'.format(commit_id1_short)),
         ])
 
     @pytest.mark.xfail_backends("svn")
     def test_source_repo_new_commits_after_forking_simple_diff(self, backend):
         repo1 = backend.create_repo()
         r1_name = repo1.repo_name
 
         commit0 = commit_change(
             repo=r1_name, filename=b'file1',
             content=b'line1', message='commit1', vcs_type=backend.alias,
             newfile=True)
         assert repo1.scm_instance().commit_ids == [commit0.raw_id]
 
         # fork the repo1
         repo2 = backend.create_fork()
         assert repo2.scm_instance().commit_ids == [commit0.raw_id]
 
         self.r2_id = repo2.repo_id
         r2_name = repo2.repo_name
 
         commit1 = commit_change(
             repo=r2_name, filename=b'file1-fork',
             content=b'file1-line1-from-fork', message='commit1-fork',
             vcs_type=backend.alias, parent=repo2.scm_instance()[-1],
             newfile=True)
 
         commit2 = commit_change(
             repo=r2_name, filename=b'file2-fork',
             content=b'file2-line1-from-fork', message='commit2-fork',
             vcs_type=backend.alias, parent=commit1,
             newfile=True)
 
         commit_change(  # commit 3
             repo=r2_name, filename=b'file3-fork',
             content=b'file3-line1-from-fork', message='commit3-fork',
             vcs_type=backend.alias, parent=commit2, newfile=True)
 
         # compare !
         commit_id1 = repo1.scm_instance().DEFAULT_BRANCH_NAME
         commit_id2 = repo2.scm_instance().DEFAULT_BRANCH_NAME
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=r2_name,
                        source_ref_type="branch", source_ref=commit_id1,
                        target_ref_type="branch", target_ref=commit_id2,
                        params=dict(merge='1', target_repo=r1_name),
                        ))
 
         response.mustcontain('%s@%s' % (r2_name, commit_id1))
         response.mustcontain('%s@%s' % (r1_name, commit_id2))
         response.mustcontain('No files')
         response.mustcontain('No commits in this compare')
 
         commit0 = commit_change(
             repo=r1_name, filename=b'file2',
             content=b'line1-added-after-fork', message='commit2-parent',
             vcs_type=backend.alias, parent=None, newfile=True)
 
         # compare !
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=r2_name,
                        source_ref_type="branch", source_ref=commit_id1,
                        target_ref_type="branch", target_ref=commit_id2,
                        params=dict(merge='1', target_repo=r1_name),
                        ))
 
         response.mustcontain('%s@%s' % (r2_name, commit_id1))
         response.mustcontain('%s@%s' % (r1_name, commit_id2))
 
         response.mustcontain("""commit2-parent""")
         response.mustcontain("""line1-added-after-fork""")
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 1, 0)
 
     @pytest.mark.xfail_backends("svn")
     def test_compare_commits(self, backend, xhr_header):
         commit0 = backend.repo.get_commit(commit_idx=0)
         commit1 = backend.repo.get_commit(commit_idx=1)
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=backend.repo_name,
                        source_ref_type="rev", source_ref=commit0.raw_id,
                        target_ref_type="rev", target_ref=commit1.raw_id,
                        params=dict(merge='1')
                        ),
             extra_environ=xhr_header, )
 
         # outgoing commits between those commits
         compare_page = ComparePage(response)
         compare_page.contains_commits(commits=[commit1])
 
     def test_errors_when_comparing_unknown_source_repo(self, backend):
         repo = backend.repo
 
         self.app.get(
             route_path('repo_compare',
                        repo_name='badrepo',
                        source_ref_type="rev", source_ref='tip',
                        target_ref_type="rev", target_ref='tip',
                        params=dict(merge='1', target_repo=repo.repo_name)
                        ),
             status=404)
 
     def test_errors_when_comparing_unknown_target_repo(self, backend):
         repo = backend.repo
         badrepo = 'badrepo'
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=repo.repo_name,
                        source_ref_type="rev", source_ref='tip',
                        target_ref_type="rev", target_ref='tip',
                        params=dict(merge='1', target_repo=badrepo),
                        ),
             status=302)
         redirected = response.follow()
         redirected.mustcontain(
             'Could not find the target repo: `{}`'.format(badrepo))
 
     def test_compare_not_in_preview_mode(self, backend_stub):
         commit0 = backend_stub.repo.get_commit(commit_idx=0)
         commit1 = backend_stub.repo.get_commit(commit_idx=1)
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=backend_stub.repo_name,
                        source_ref_type="rev", source_ref=commit0.raw_id,
                        target_ref_type="rev", target_ref=commit1.raw_id,
                        ))
 
         # outgoing commits between those commits
         compare_page = ComparePage(response)
         compare_page.swap_is_visible()
         compare_page.target_source_are_enabled()
 
     def test_compare_of_fork_with_largefiles(self, backend_hg, settings_util):
         orig = backend_hg.create_repo(number_of_commits=1)
         fork = backend_hg.create_fork()
 
         settings_util.create_repo_rhodecode_ui(
             orig, 'extensions', value='', key='largefiles', active=False)
         settings_util.create_repo_rhodecode_ui(
             fork, 'extensions', value='', key='largefiles', active=True)
 
         compare_module = ('rhodecode.lib.vcs.backends.hg.repository.'
                           'MercurialRepository.compare')
         with mock.patch(compare_module) as compare_mock:
             compare_mock.side_effect = RepositoryRequirementError()
 
             response = self.app.get(
                 route_path('repo_compare',
                            repo_name=orig.repo_name,
                            source_ref_type="rev", source_ref="tip",
                            target_ref_type="rev", target_ref="tip",
                            params=dict(merge='1', target_repo=fork.repo_name),
                            ),
                 status=302)
 
             assert_session_flash(
                 response,
                 'Could not compare repos with different large file settings')
 
 
 @pytest.mark.usefixtures("autologin_user")
 class TestCompareControllerSvn(object):
 
     def test_supports_references_with_path(self, app, backend_svn):
         repo = backend_svn['svn-simple-layout']
         commit_id = repo.get_commit(commit_idx=-1).raw_id
         response = app.get(
             route_path('repo_compare',
                        repo_name=repo.repo_name,
                        source_ref_type="tag",
                        source_ref="%s@%s" % ('tags/v0.1', commit_id),
                        target_ref_type="tag",
                        target_ref="%s@%s" % ('tags/v0.2', commit_id),
                        params=dict(merge='1'),
                        ),
             status=200)
 
         # Expecting no commits, since both paths are at the same revision
         response.mustcontain('No commits in this compare')
 
         # Should find only one file changed when comparing those two tags
         response.mustcontain('example.py')
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 5, 1)
 
     def test_shows_commits_if_different_ids(self, app, backend_svn):
         repo = backend_svn['svn-simple-layout']
         source_id = repo.get_commit(commit_idx=-6).raw_id
         target_id = repo.get_commit(commit_idx=-1).raw_id
         response = app.get(
             route_path('repo_compare',
                        repo_name=repo.repo_name,
                        source_ref_type="tag",
                        source_ref="%s@%s" % ('tags/v0.1', source_id),
                        target_ref_type="tag",
                        target_ref="%s@%s" % ('tags/v0.2', target_id),
                        params=dict(merge='1')
                        ),
             status=200)
 
         # It should show commits
         assert 'No commits in this compare' not in response.text
 
         # Should find only one file changed when comparing those two tags
         response.mustcontain('example.py')
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 5, 1)
 
 
 class ComparePage(AssertResponse):
     """
     Abstracts the page template from the tests
     """
 
     def contains_file_links_and_anchors(self, files):
         doc = lxml.html.fromstring(self.response.body)
         for filename, file_id in files:
             self.contains_one_anchor(file_id)
             diffblock = doc.cssselect('[data-f-path="%s"]' % filename)
             assert len(diffblock) == 2
             for lnk in diffblock[0].cssselect('a'):
                 if 'permalink' in lnk.text:
                     assert '#{}'.format(file_id) in lnk.attrib['href']
                     break
             else:
                 pytest.fail('Unable to find permalink')
 
     def contains_change_summary(self, files_changed, inserted, deleted):
         template = (
             '{files_changed} file{plural} changed: '
             '<span class="op-added">{inserted} inserted</span>, <span class="op-deleted">{deleted} deleted</span>')
         self.response.mustcontain(template.format(
             files_changed=files_changed,
             plural="s" if files_changed > 1 else "",
             inserted=inserted,
             deleted=deleted))
 
     def contains_commits(self, commits, ancestors=None):
         response = self.response
 
         for commit in commits:
             # Expecting to see the commit message in an element which
             # has the ID "c-{commit.raw_id}"
             self.element_contains('#c-' + commit.raw_id, commit.message)
             self.contains_one_link(
                 'r%s:%s' % (commit.idx, commit.short_id),
                 self._commit_url(commit))
 
         if ancestors:
             response.mustcontain('Ancestor')
             for ancestor in ancestors:
                 self.contains_one_link(
                     ancestor.short_id, self._commit_url(ancestor))
 
     def _commit_url(self, commit):
         return '/%s/changeset/%s' % (commit.repository.name, commit.raw_id)
 
     def swap_is_hidden(self):
         assert '<a id="btn-swap"' not in self.response.text
 
     def swap_is_visible(self):
         assert '<a id="btn-swap"' in self.response.text
 
     def target_source_are_disabled(self):
         response = self.response
         response.mustcontain("var enable_fields = false;")
         response.mustcontain('.select2("enable", enable_fields)')
 
     def target_source_are_enabled(self):
         response = self.response
         response.mustcontain("var enable_fields = true;")

rhodecode/apps/repository/tests/test_repo_compare_local.py

@@ -1,168 +1,154 b''
 
 # 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 .test_repo_compare import ComparePage
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'repo_compare_select': '/{repo_name}/compare',
-        'repo_compare': '/{repo_name}/compare/{source_ref_type}@{source_ref}...{target_ref_type}@{target_ref}',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests.routes import route_path
 
 
 @pytest.mark.usefixtures("autologin_user", "app")
 class TestCompareView(object):
 
     @pytest.mark.xfail_backends("svn", msg="Depends on branch and tag support")
     def test_compare_tag(self, backend):
         tag1 = 'v0.1.2'
         tag2 = 'v0.1.3'
         response = self.app.get(
             route_path(
                 'repo_compare',
                 repo_name=backend.repo_name,
                 source_ref_type="tag", source_ref=tag1,
                 target_ref_type="tag", target_ref=tag2),
             status=200)
 
         response.mustcontain('%s@%s' % (backend.repo_name, tag1))
         response.mustcontain('%s@%s' % (backend.repo_name, tag2))
 
         # outgoing commits between tags
         commit_indexes = {
             'git': [113] + list(range(115, 121)),
             'hg': [112] + list(range(115, 121)),
         }
         repo = backend.repo
         commits = (repo.get_commit(commit_idx=idx)
                    for idx in commit_indexes[backend.alias])
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(11, 94, 64)
         compare_page.contains_commits(commits)
 
         # files diff
         short_id = short_id_new = ''
         if backend.alias == 'git':
             short_id = '5a3a8fb00555'
             short_id_new = '0ba5f8a46600'
         if backend.alias == 'hg':
             short_id = '17544fbfcd33'
             short_id_new = 'a7e60bff65d5'
 
         compare_page.contains_file_links_and_anchors([
             # modified
             ('docs/api/utils/index.rst', 'a_c-{}-1c5cf9e91c12'.format(short_id)),
             ('test_and_report.sh', 'a_c-{}-e3305437df55'.format(short_id)),
             # added
             ('.hgignore', 'a_c-{}-c8e92ef85cd1'.format(short_id_new)),
             ('.hgtags', 'a_c-{}-6e08b694d687'.format(short_id_new)),
             ('docs/api/index.rst', 'a_c-{}-2c14b00f3393'.format(short_id_new)),
             ('vcs/__init__.py', 'a_c-{}-430ccbc82bdf'.format(short_id_new)),
             ('vcs/backends/hg.py', 'a_c-{}-9c390eb52cd6'.format(short_id_new)),
             ('vcs/utils/__init__.py', 'a_c-{}-ebb592c595c0'.format(short_id_new)),
             ('vcs/utils/annotate.py', 'a_c-{}-7abc741b5052'.format(short_id_new)),
             ('vcs/utils/diffs.py', 'a_c-{}-2ef0ef106c56'.format(short_id_new)),
             ('vcs/utils/lazy.py', 'a_c-{}-3150cb87d4b7'.format(short_id_new)),
         ])
 
     @pytest.mark.xfail_backends("svn", msg="Depends on branch and tag support")
     def test_compare_tag_branch(self, backend):
         revisions = {
             'hg': {
                 'tag': 'v0.2.0',
                 'branch': 'default',
                 'response': (147, 5701, 10177)
             },
             'git': {
                 'tag': 'v0.2.2',
                 'branch': 'master',
                 'response': (70, 1855, 3002)
             },
         }
 
         # Backend specific data, depends on the test repository for
         # functional tests.
         data = revisions[backend.alias]
 
         response = self.app.get(
             route_path(
                 'repo_compare',
                 repo_name=backend.repo_name,
                 source_ref_type='branch', source_ref=data['branch'],
                 target_ref_type="tag", target_ref=data['tag'],
             ))
 
         response.mustcontain('%s@%s' % (backend.repo_name, data['branch']))
         response.mustcontain('%s@%s' % (backend.repo_name, data['tag']))
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(*data['response'])
 
     def test_index_branch(self, backend):
         head_id = backend.default_head_id
         response = self.app.get(
             route_path(
                 'repo_compare',
                 repo_name=backend.repo_name,
                 source_ref_type="branch", source_ref=head_id,
                 target_ref_type="branch", target_ref=head_id,
             ))
 
         response.mustcontain('%s@%s' % (backend.repo_name, head_id))
 
         # branches are equal
         response.mustcontain('No files')
         response.mustcontain('No commits in this compare')
 
     def test_compare_commits(self, backend):
         repo = backend.repo
         commit1 = repo.get_commit(commit_idx=0)
         commit1_short_id = commit1.short_id
         commit2 = repo.get_commit(commit_idx=1)
         commit2_short_id = commit2.short_id
 
         response = self.app.get(
             route_path(
                 'repo_compare',
                 repo_name=backend.repo_name,
                 source_ref_type="rev", source_ref=commit1.raw_id,
                 target_ref_type="rev", target_ref=commit2.raw_id,
             ))
         response.mustcontain('%s@%s' % (backend.repo_name, commit1.raw_id))
         response.mustcontain('%s@%s' % (backend.repo_name, commit2.raw_id))
         compare_page = ComparePage(response)
 
         # files
         compare_page.contains_change_summary(1, 7, 0)
 
         # outgoing commits between those commits
         compare_page.contains_commits([commit2])
         anchor = 'a_c-{}-c8e92ef85cd1'.format(commit2_short_id)
         response.mustcontain(anchor)
         compare_page.contains_file_links_and_anchors([('.hgignore', anchor),])

rhodecode/apps/repository/tests/test_repo_compare_on_single_file.py

@@ -1,292 +1,279 b''
 
 # 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.apps.repository.tests.test_repo_compare import ComparePage
 from rhodecode.lib.vcs import nodes
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.tests.fixture import Fixture
 from rhodecode.tests.utils import commit_change
-
-fixture = Fixture()
+from rhodecode.tests.routes import route_path
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'repo_compare_select': '/{repo_name}/compare',
-        'repo_compare': '/{repo_name}/compare/{source_ref_type}@{source_ref}...{target_ref_type}@{target_ref}',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+fixture = Fixture()
 
 
 @pytest.mark.usefixtures("autologin_user", "app")
 class TestSideBySideDiff(object):
 
     def test_diff_sidebyside_single_commit(self, app, backend):
         commit_id_range = {
             'hg': {
                 'commits': ['25d7e49c18b159446cadfa506a5cf8ad1cb04067',
                             '603d6c72c46d953420c89d36372f08d9f305f5dd'],
                 'changes': (21, 943, 288),
             },
             'git': {
                 'commits': ['6fc9270775aaf5544c1deb014f4ddd60c952fcbb',
                             '03fa803d7e9fb14daa9a3089e0d1494eda75d986'],
                 'changes': (20, 941, 286),
             },
 
             'svn': {
                 'commits': ['336',
                             '337'],
                 'changes': (21, 943, 288),
             },
         }
 
         commit_info = commit_id_range[backend.alias]
         commit2, commit1 = commit_info['commits']
         file_changes = commit_info['changes']
 
         response = self.app.get(route_path(
             'repo_compare',
             repo_name=backend.repo_name,
             source_ref_type='rev',
             source_ref=commit2,
             target_repo=backend.repo_name,
             target_ref_type='rev',
             target_ref=commit1,
             params=dict(target_repo=backend.repo_name, diffmode='sidebyside')
         ))
 
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(*file_changes)
         response.mustcontain('Collapse 1 commit')
 
     def test_diff_sidebyside_two_commits(self, app, backend):
         commit_id_range = {
             'hg': {
                 'commits': ['4fdd71e9427417b2e904e0464c634fdee85ec5a7',
                             '603d6c72c46d953420c89d36372f08d9f305f5dd'],
                 'changes': (32, 1165, 308),
             },
             'git': {
                 'commits': ['f5fbf9cfd5f1f1be146f6d3b38bcd791a7480c13',
                             '03fa803d7e9fb14daa9a3089e0d1494eda75d986'],
                 'changes': (31, 1163, 306),
             },
 
             'svn': {
                 'commits': ['335',
                             '337'],
                 'changes': (32, 1179, 310),
             },
         }
 
         commit_info = commit_id_range[backend.alias]
         commit2, commit1 = commit_info['commits']
         file_changes = commit_info['changes']
 
         response = self.app.get(route_path(
             'repo_compare',
             repo_name=backend.repo_name,
             source_ref_type='rev',
             source_ref=commit2,
             target_repo=backend.repo_name,
             target_ref_type='rev',
             target_ref=commit1,
             params=dict(target_repo=backend.repo_name, diffmode='sidebyside')
         ))
 
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(*file_changes)
 
         response.mustcontain('Collapse 2 commits')
 
     def test_diff_sidebyside_collapsed_commits(self, app, backend_svn):
         commit_id_range = {
 
             'svn': {
                 'commits': ['330',
                             '337'],
 
             },
         }
 
         commit_info = commit_id_range['svn']
         commit2, commit1 = commit_info['commits']
 
         response = self.app.get(route_path(
             'repo_compare',
             repo_name=backend_svn.repo_name,
             source_ref_type='rev',
             source_ref=commit2,
             target_repo=backend_svn.repo_name,
             target_ref_type='rev',
             target_ref=commit1,
             params=dict(target_repo=backend_svn.repo_name, diffmode='sidebyside')
         ))
 
         response.mustcontain('Expand 7 commits')
 
     @pytest.mark.xfail(reason='GIT does not handle empty commit compare correct (missing 1 commit)')
     def test_diff_side_by_side_from_0_commit(self, app, backend, backend_stub):
         f_path = b'test_sidebyside_file.py'
         commit1_content = b'content-25d7e49c18b159446c\n'
         commit2_content = b'content-603d6c72c46d953420\n'
         repo = backend.create_repo()
 
         commit1 = commit_change(
             repo.repo_name, filename=f_path, content=commit1_content,
             message='A', vcs_type=backend.alias, parent=None, newfile=True)
 
         commit2 = commit_change(
             repo.repo_name, filename=f_path, content=commit2_content,
             message='B, child of A', vcs_type=backend.alias, parent=commit1)
 
         response = self.app.get(route_path(
             'repo_compare',
             repo_name=repo.repo_name,
             source_ref_type='rev',
             source_ref=EmptyCommit().raw_id,
             target_ref_type='rev',
             target_ref=commit2.raw_id,
             params=dict(diffmode='sidebyside')
         ))
 
         response.mustcontain('Collapse 2 commits')
         response.mustcontain('123 file changed')
 
         response.mustcontain(
             'r%s:%s...r%s:%s' % (
                 commit1.idx, commit1.short_id, commit2.idx, commit2.short_id))
 
         response.mustcontain(f_path)
 
     @pytest.mark.xfail(reason='GIT does not handle empty commit compare correct (missing 1 commit)')
     def test_diff_side_by_side_from_0_commit_with_file_filter(self, app, backend, backend_stub):
         f_path = b'test_sidebyside_file.py'
         commit1_content = b'content-25d7e49c18b159446c\n'
         commit2_content = b'content-603d6c72c46d953420\n'
         repo = backend.create_repo()
 
         commit1 = commit_change(
             repo.repo_name, filename=f_path, content=commit1_content,
             message='A', vcs_type=backend.alias, parent=None, newfile=True)
 
         commit2 = commit_change(
             repo.repo_name, filename=f_path, content=commit2_content,
             message='B, child of A', vcs_type=backend.alias, parent=commit1)
 
         response = self.app.get(route_path(
             'repo_compare',
             repo_name=repo.repo_name,
             source_ref_type='rev',
             source_ref=EmptyCommit().raw_id,
             target_ref_type='rev',
             target_ref=commit2.raw_id,
             params=dict(f_path=f_path, target_repo=repo.repo_name, diffmode='sidebyside')
         ))
 
         response.mustcontain('Collapse 2 commits')
         response.mustcontain('1 file changed')
 
         response.mustcontain(
             'r%s:%s...r%s:%s' % (
                 commit1.idx, commit1.short_id, commit2.idx, commit2.short_id))
 
         response.mustcontain(f_path)
 
     def test_diff_side_by_side_with_empty_file(self, app, backend, backend_stub):
         commits = [
             {'message': 'First commit'},
             {'message': 'Second commit'},
             {'message': 'Commit with binary',
              'added': [nodes.FileNode(b'file.empty', content=b'')]},
         ]
         f_path = 'file.empty'
         repo = backend.create_repo(commits=commits)
         commit1 = repo.get_commit(commit_idx=0)
         commit2 = repo.get_commit(commit_idx=1)
         commit3 = repo.get_commit(commit_idx=2)
 
         response = self.app.get(route_path(
             'repo_compare',
             repo_name=repo.repo_name,
             source_ref_type='rev',
             source_ref=commit1.raw_id,
             target_ref_type='rev',
             target_ref=commit3.raw_id,
             params=dict(f_path=f_path, target_repo=repo.repo_name, diffmode='sidebyside')
         ))
 
         response.mustcontain('Collapse 2 commits')
         response.mustcontain('1 file changed')
 
         response.mustcontain(
             'r%s:%s...r%s:%s' % (
                 commit2.idx, commit2.short_id, commit3.idx, commit3.short_id))
 
         response.mustcontain(f_path)
 
     def test_diff_sidebyside_two_commits_with_file_filter(self, app, backend):
         commit_id_range = {
             'hg': {
                 'commits': ['4fdd71e9427417b2e904e0464c634fdee85ec5a7',
                             '603d6c72c46d953420c89d36372f08d9f305f5dd'],
                 'changes': (1, 3, 3)
             },
             'git': {
                 'commits': ['f5fbf9cfd5f1f1be146f6d3b38bcd791a7480c13',
                             '03fa803d7e9fb14daa9a3089e0d1494eda75d986'],
                 'changes': (1, 3, 3)
             },
 
             'svn': {
                 'commits': ['335',
                             '337'],
                 'changes': (1, 3, 3)
             },
         }
         f_path = 'docs/conf.py'
 
         commit_info = commit_id_range[backend.alias]
         commit2, commit1 = commit_info['commits']
         file_changes = commit_info['changes']
 
         response = self.app.get(route_path(
             'repo_compare',
             repo_name=backend.repo_name,
             source_ref_type='rev',
             source_ref=commit2,
             target_ref_type='rev',
             target_ref=commit1,
             params=dict(f_path=f_path, target_repo=backend.repo_name, diffmode='sidebyside')
         ))
 
         response.mustcontain('Collapse 2 commits')
 
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(*file_changes)

rhodecode/apps/repository/tests/test_repo_feed.py

@@ -1,138 +1,122 b''
 
 # 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.auth_token import AuthTokenModel
 from rhodecode.tests import TestController
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'rss_feed_home': '/{repo_name}/feed-rss',
-        'atom_feed_home': '/{repo_name}/feed-atom',
-        'rss_feed_home_old': '/{repo_name}/feed/rss',
-        'atom_feed_home_old': '/{repo_name}/feed/atom',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests.routes import route_path
 
 
 class TestFeedView(TestController):
 
     @pytest.mark.parametrize("feed_type,response_types,content_type",[
         ('rss', ['<rss version="2.0"'],
          "application/rss+xml"),
         ('atom', ['xmlns="http://www.w3.org/2005/Atom"', 'xml:lang="en-us"'],
          "application/atom+xml"),
     ])
     def test_feed(self, backend, feed_type, response_types, content_type):
         self.log_user()
         response = self.app.get(
             route_path('{}_feed_home'.format(feed_type),
                        repo_name=backend.repo_name))
 
         for content in response_types:
             response.mustcontain(content)
 
         assert response.content_type == content_type
 
     @pytest.mark.parametrize("feed_type, content_type", [
         ('rss', "application/rss+xml"),
         ('atom', "application/atom+xml")
     ])
     def test_feed_with_auth_token(
             self, backend, user_admin, feed_type, content_type):
         auth_token = user_admin.feed_token
         assert auth_token != ''
 
         response = self.app.get(
             route_path(
                 '{}_feed_home'.format(feed_type),
                 repo_name=backend.repo_name,
                 params=dict(auth_token=auth_token)),
             status=200)
 
         assert response.content_type == content_type
 
     @pytest.mark.parametrize("feed_type, content_type", [
         ('rss', "application/rss+xml"),
         ('atom', "application/atom+xml")
     ])
     def test_feed_with_auth_token_by_uid(
             self, backend, user_admin, feed_type, content_type):
         auth_token = user_admin.feed_token
         assert auth_token != ''
 
         response = self.app.get(
             route_path(
                 '{}_feed_home'.format(feed_type),
                 repo_name='_{}'.format(backend.repo.repo_id),
                 params=dict(auth_token=auth_token)),
             status=200)
 
         assert response.content_type == content_type
 
     @pytest.mark.parametrize("feed_type, content_type", [
         ('rss', "application/rss+xml"),
         ('atom', "application/atom+xml")
     ])
     def test_feed_old_urls_with_auth_token(
             self, backend, user_admin, feed_type, content_type):
         auth_token = user_admin.feed_token
         assert auth_token != ''
 
         response = self.app.get(
             route_path(
                 '{}_feed_home_old'.format(feed_type),
                 repo_name=backend.repo_name,
                 params=dict(auth_token=auth_token)),
             status=200)
 
         assert response.content_type == content_type
 
     @pytest.mark.parametrize("feed_type", ['rss', 'atom'])
     def test_feed_with_auth_token_of_wrong_type(
             self, backend, user_util, feed_type):
         user = user_util.create_user()
         auth_token = AuthTokenModel().create(
             user.user_id, u'test-token', -1, AuthTokenModel.cls.ROLE_API)
         auth_token = auth_token.api_key
 
         self.app.get(
             route_path(
                 '{}_feed_home'.format(feed_type),
                 repo_name=backend.repo_name,
                 params=dict(auth_token=auth_token)),
             status=302)
 
         auth_token = AuthTokenModel().create(
             user.user_id, u'test-token', -1, AuthTokenModel.cls.ROLE_FEED)
         auth_token = auth_token.api_key
         self.app.get(
             route_path(
                 '{}_feed_home'.format(feed_type),
                 repo_name=backend.repo_name,
                 params=dict(auth_token=auth_token)),
             status=200)

rhodecode/apps/repository/tests/test_repo_files.py

@@ -1,1125 +1,1090 b''
 
 # 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 collections import OrderedDict
 
 from rhodecode.apps.repository.tests.test_repo_compare import ComparePage
 from rhodecode.apps.repository.views.repo_files import RepoFilesView, get_archive_name, get_path_sha
 from rhodecode.lib import helpers as h
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.str_utils import safe_str
 from rhodecode.lib.vcs import nodes
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.model.db import Session, Repository
 
 from rhodecode.tests import assert_session_flash
 from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
+
 
 fixture = Fixture()
 
 
 def get_node_history(backend_type):
     return {
         'hg': json.loads(fixture.load_resource('hg_node_history_response.json')),
         'git': json.loads(fixture.load_resource('git_node_history_response.json')),
         'svn': json.loads(fixture.load_resource('svn_node_history_response.json')),
     }[backend_type]
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'repo_summary': '/{repo_name}',
-        'repo_archivefile': '/{repo_name}/archive/{fname}',
-        'repo_files_diff': '/{repo_name}/diff/{f_path}',
-        'repo_files_diff_2way_redirect':  '/{repo_name}/diff-2way/{f_path}',
-        'repo_files': '/{repo_name}/files/{commit_id}/{f_path}',
-        'repo_files:default_path': '/{repo_name}/files/{commit_id}/',
-        'repo_files:default_commit': '/{repo_name}/files',
-        'repo_files:rendered': '/{repo_name}/render/{commit_id}/{f_path}',
-        'repo_files:annotated': '/{repo_name}/annotate/{commit_id}/{f_path}',
-        'repo_files:annotated_previous': '/{repo_name}/annotate-previous/{commit_id}/{f_path}',
-        'repo_files_nodelist': '/{repo_name}/nodelist/{commit_id}/{f_path}',
-        'repo_file_raw': '/{repo_name}/raw/{commit_id}/{f_path}',
-        'repo_file_download': '/{repo_name}/download/{commit_id}/{f_path}',
-        'repo_file_history': '/{repo_name}/history/{commit_id}/{f_path}',
-        'repo_file_authors': '/{repo_name}/authors/{commit_id}/{f_path}',
-        'repo_files_remove_file': '/{repo_name}/remove_file/{commit_id}/{f_path}',
-        'repo_files_delete_file': '/{repo_name}/delete_file/{commit_id}/{f_path}',
-        'repo_files_edit_file': '/{repo_name}/edit_file/{commit_id}/{f_path}',
-        'repo_files_update_file': '/{repo_name}/update_file/{commit_id}/{f_path}',
-        'repo_files_add_file': '/{repo_name}/add_file/{commit_id}/{f_path}',
-        'repo_files_upload_file': '/{repo_name}/upload_file/{commit_id}/{f_path}',
-        'repo_files_create_file': '/{repo_name}/create_file/{commit_id}/{f_path}',
-        'repo_nodetree_full': '/{repo_name}/nodetree_full/{commit_id}/{f_path}',
-        'repo_nodetree_full:default_path': '/{repo_name}/nodetree_full/{commit_id}/',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 def assert_files_in_response(response, files, params):
     template = (
         'href="/%(repo_name)s/files/%(commit_id)s/%(name)s"')
     _assert_items_in_response(response, files, template, params)
 
 
 def assert_dirs_in_response(response, dirs, params):
     template = (
         'href="/%(repo_name)s/files/%(commit_id)s/%(name)s"')
     _assert_items_in_response(response, dirs, template, params)
 
 
 def _assert_items_in_response(response, items, template, params):
     for item in items:
         item_params = {'name': item}
         item_params.update(params)
         response.mustcontain(template % item_params)
 
 
 def assert_timeago_in_response(response, items, params):
     for item in items:
         response.mustcontain(h.age_component(params['date']))
 
 
 @pytest.mark.usefixtures("app")
 class TestFilesViews(object):
 
     def test_show_files(self, backend):
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'))
         commit = backend.repo.get_commit()
 
         params = {
             'repo_name': backend.repo_name,
             'commit_id': commit.raw_id,
             'date': commit.date
         }
         assert_dirs_in_response(response, ['docs', 'vcs'], params)
         files = [
             '.gitignore',
             '.hgignore',
             '.hgtags',
             # TODO: missing in Git
             # '.travis.yml',
             'MANIFEST.in',
             'README.rst',
             # TODO: File is missing in svn repository
             # 'run_test_and_report.sh',
             'setup.cfg',
             'setup.py',
             'test_and_report.sh',
             'tox.ini',
         ]
         assert_files_in_response(response, files, params)
         assert_timeago_in_response(response, files, params)
 
     def test_show_files_links_submodules_with_absolute_url(self, backend_hg):
         repo = backend_hg['subrepos']
         response = self.app.get(
             route_path('repo_files',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'))
         assert_response = response.assert_response()
         assert_response.contains_one_link(
             'absolute-path @ 000000000000', 'http://example.com/absolute-path')
 
     def test_show_files_links_submodules_with_absolute_url_subpaths(
             self, backend_hg):
         repo = backend_hg['subrepos']
         response = self.app.get(
             route_path('repo_files',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'))
         assert_response = response.assert_response()
         assert_response.contains_one_link(
             'subpaths-path @ 000000000000',
             'http://sub-base.example.com/subpaths-path')
 
     @pytest.mark.xfail_backends("svn", reason="Depends on branch support")
     def test_files_menu(self, backend):
         new_branch = "temp_branch_name"
         commits = [
             {'message': 'a'},
             {'message': 'b', 'branch': new_branch}
         ]
         backend.create_repo(commits)
         backend.repo.landing_rev = f"branch:{new_branch}"
         Session().commit()
 
         # get response based on tip and not new commit
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'))
 
         # make sure Files menu url is not tip but new commit
         landing_rev = backend.repo.landing_ref_name
         files_url = route_path('repo_files:default_path',
                                repo_name=backend.repo_name,
                                commit_id=landing_rev, params={'at': landing_rev})
 
         assert landing_rev != 'tip'
         response.mustcontain(f'<li class="active"><a class="menulink" href="{files_url}">')
 
     def test_show_files_commit(self, backend):
         commit = backend.repo.get_commit(commit_idx=32)
 
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/'))
 
         dirs = ['docs', 'tests']
         files = ['README.rst']
         params = {
             'repo_name': backend.repo_name,
             'commit_id': commit.raw_id,
         }
         assert_dirs_in_response(response, dirs, params)
         assert_files_in_response(response, files, params)
 
     def test_show_files_different_branch(self, backend):
         branches = dict(
             hg=(150, ['git']),
             # TODO: Git test repository does not contain other branches
             git=(633, ['master']),
             # TODO: Branch support in Subversion
             svn=(150, [])
         )
         idx, branches = branches[backend.alias]
         commit = backend.repo.get_commit(commit_idx=idx)
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/'))
 
         assert_response = response.assert_response()
         for branch in branches:
             assert_response.element_contains('.tags .branchtag', branch)
 
     def test_show_files_paging(self, backend):
         repo = backend.repo
         indexes = [73, 92, 109, 1, 0]
         idx_map = [(rev, repo.get_commit(commit_idx=rev).raw_id)
                    for rev in indexes]
 
         for idx in idx_map:
             response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id=idx[1], f_path='/'))
 
             response.mustcontain("""r%s:%s""" % (idx[0], idx[1][:8]))
 
     def test_file_source(self, backend):
         commit = backend.repo.get_commit(commit_idx=167)
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='vcs/nodes.py'))
 
         msgbox = """<div class="commit">%s</div>"""
         response.mustcontain(msgbox % (commit.message, ))
 
         assert_response = response.assert_response()
         if commit.branch:
             assert_response.element_contains(
                 '.tags.tags-main .branchtag', commit.branch)
         if commit.tags:
             for tag in commit.tags:
                 assert_response.element_contains('.tags.tags-main .tagtag', tag)
 
     def test_file_source_annotated(self, backend):
         response = self.app.get(
             route_path('repo_files:annotated',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py'))
         expected_commits = {
             'hg': 'r356',
             'git': 'r345',
             'svn': 'r208',
         }
         response.mustcontain(expected_commits[backend.alias])
 
     def test_file_source_authors(self, backend):
         response = self.app.get(
             route_path('repo_file_authors',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py'))
         expected_authors = {
             'hg': ('Marcin Kuzminski', 'Lukasz Balcerzak'),
             'git': ('Marcin Kuzminski', 'Lukasz Balcerzak'),
             'svn': ('marcin', 'lukasz'),
         }
 
         for author in expected_authors[backend.alias]:
             response.mustcontain(author)
 
     def test_file_source_authors_with_annotation(self, backend):
         response = self.app.get(
             route_path('repo_file_authors',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py',
                        params=dict(annotate=1)))
         expected_authors = {
             'hg': ('Marcin Kuzminski', 'Lukasz Balcerzak'),
             'git': ('Marcin Kuzminski', 'Lukasz Balcerzak'),
             'svn': ('marcin', 'lukasz'),
         }
 
         for author in expected_authors[backend.alias]:
             response.mustcontain(author)
 
     def test_file_source_history(self, backend, xhr_header):
         response = self.app.get(
             route_path('repo_file_history',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py'),
             extra_environ=xhr_header)
         assert get_node_history(backend.alias) == json.loads(response.body)
 
     def test_file_source_history_svn(self, backend_svn, xhr_header):
         simple_repo = backend_svn['svn-simple-layout']
         response = self.app.get(
             route_path('repo_file_history',
                        repo_name=simple_repo.repo_name,
                        commit_id='tip', f_path='trunk/example.py'),
             extra_environ=xhr_header)
 
         expected_data = json.loads(
             fixture.load_resource('svn_node_history_branches.json'))
 
         assert expected_data == response.json
 
     def test_file_source_history_with_annotation(self, backend, xhr_header):
         response = self.app.get(
             route_path('repo_file_history',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py',
                        params=dict(annotate=1)),
 
             extra_environ=xhr_header)
         assert get_node_history(backend.alias) == json.loads(response.body)
 
     def test_tree_search_top_level(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/'),
             extra_environ=xhr_header)
         assert 'nodes' in response.json
         assert {'name': 'docs', 'type': 'dir'} in response.json['nodes']
 
     def test_tree_search_missing_xhr(self, backend):
         self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'),
             status=404)
 
     def test_tree_search_at_path(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/docs'),
             extra_environ=xhr_header)
         assert 'nodes' in response.json
         nodes = response.json['nodes']
         assert {'name': 'docs/api', 'type': 'dir'} in nodes
         assert {'name': 'docs/index.rst', 'type': 'file'} in nodes
 
     def test_tree_search_at_path_2nd_level(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/docs/api'),
             extra_environ=xhr_header)
         assert 'nodes' in response.json
         nodes = response.json['nodes']
         assert {'name': 'docs/api/index.rst', 'type': 'file'} in nodes
 
     def test_tree_search_at_path_missing_xhr(self, backend):
         self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/docs'),
             status=404)
 
     def test_nodetree(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_nodetree_full',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/'),
             extra_environ=xhr_header)
 
         assert_response = response.assert_response()
 
         for attr in ['data-commit-id', 'data-date', 'data-author']:
             elements = assert_response.get_elements('[{}]'.format(attr))
             assert len(elements) > 1
 
             for element in elements:
                 assert element.get(attr)
 
     def test_nodetree_if_file(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_nodetree_full',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='README.rst'),
             extra_environ=xhr_header)
         assert response.text == ''
 
     def test_nodetree_wrong_path(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_nodetree_full',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/dont-exist'),
             extra_environ=xhr_header)
 
         err = 'error: There is no file nor ' \
               'directory at the given path'
         assert err in response.text
 
     def test_nodetree_missing_xhr(self, backend):
         self.app.get(
             route_path('repo_nodetree_full',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'),
             status=404)
 
 
 @pytest.mark.usefixtures("app", "autologin_user")
 class TestRawFileHandling(object):
 
     def test_download_file(self, backend):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_file_download',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='vcs/nodes.py'),)
 
         assert response.content_disposition == 'attachment; filename="nodes.py"; filename*=UTF-8\'\'nodes.py'
         assert response.content_type == "text/x-python"
 
     def test_download_file_wrong_cs(self, backend):
         raw_id = u'ERRORce30c96924232dffcd24178a07ffeb5dfc'
 
         response = self.app.get(
             route_path('repo_file_download',
                        repo_name=backend.repo_name,
                        commit_id=raw_id, f_path='vcs/nodes.svg'),
             status=404)
 
         msg = """No such commit exists for this repository"""
         response.mustcontain(msg)
 
     def test_download_file_wrong_f_path(self, backend):
         commit = backend.repo.get_commit(commit_idx=173)
         f_path = 'vcs/ERRORnodes.py'
 
         response = self.app.get(
             route_path('repo_file_download',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path=f_path),
             status=404)
 
         msg = (
             "There is no file nor directory at the given path: "
             "`%s` at commit %s" % (f_path, commit.short_id))
         response.mustcontain(msg)
 
     def test_file_raw(self, backend):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='vcs/nodes.py'),)
 
         assert response.content_type == "text/plain"
 
     def test_file_raw_binary(self, backend):
         commit = backend.repo.get_commit()
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id,
                        f_path='docs/theme/ADC/static/breadcrumb_background.png'),)
 
         assert response.content_disposition == 'inline'
 
     def test_raw_file_wrong_cs(self, backend):
         raw_id = u'ERRORcce30c96924232dffcd24178a07ffeb5dfc'
 
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id=raw_id, f_path='vcs/nodes.svg'),
             status=404)
 
         msg = """No such commit exists for this repository"""
         response.mustcontain(msg)
 
     def test_raw_wrong_f_path(self, backend):
         commit = backend.repo.get_commit(commit_idx=173)
         f_path = 'vcs/ERRORnodes.py'
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path=f_path),
             status=404)
 
         msg = (
             "There is no file nor directory at the given path: "
             "`%s` at commit %s" % (f_path, commit.short_id))
         response.mustcontain(msg)
 
     def test_raw_svg_should_not_be_rendered(self, backend):
         backend.create_repo()
         backend.ensure_file(b"xss.svg")
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='xss.svg'),)
         # If the content type is image/svg+xml then it allows to render HTML
         # and malicious SVG.
         assert response.content_type == "text/plain"
 
 
 @pytest.mark.usefixtures("app")
 class TestRepositoryArchival(object):
 
     def test_archival(self, backend):
         backend.enable_downloads()
         commit = backend.repo.get_commit(commit_idx=173)
 
         for a_type, content_type, extension in settings.ARCHIVE_SPECS:
             path_sha = get_path_sha('/')
             filename = get_archive_name(backend.repo_id, backend.repo_name, commit_sha=commit.short_id, ext=extension, path_sha=path_sha)
 
             fname = commit.raw_id + extension
             response = self.app.get(
                 route_path('repo_archivefile',
                            repo_name=backend.repo_name,
                            fname=fname))
 
             assert response.status == '200 OK'
             headers = [
                 ('Content-Disposition', f'attachment; filename={filename}'),
                 ('Content-Type', content_type),
             ]
 
             for header in headers:
                 assert header in list(response.headers.items())
 
     def test_archival_no_hash(self, backend):
         backend.enable_downloads()
         commit = backend.repo.get_commit(commit_idx=173)
         for a_type, content_type, extension in settings.ARCHIVE_SPECS:
             path_sha = get_path_sha('/')
             filename = get_archive_name(backend.repo_id, backend.repo_name, commit_sha=commit.short_id, ext=extension, path_sha=path_sha, with_hash=False)
 
             fname = commit.raw_id + extension
             response = self.app.get(
                 route_path('repo_archivefile',
                            repo_name=backend.repo_name,
                            fname=fname, params={'with_hash': 0}))
 
             assert response.status == '200 OK'
             headers = [
                 ('Content-Disposition', f'attachment; filename={filename}'),
                 ('Content-Type', content_type),
             ]
 
             for header in headers:
                 assert header in list(response.headers.items())
 
     def test_archival_at_path(self, backend):
         backend.enable_downloads()
         commit = backend.repo.get_commit(commit_idx=190)
         at_path = 'vcs'
 
         for a_type, content_type, extension in settings.ARCHIVE_SPECS:
             path_sha = get_path_sha(at_path)
             filename = get_archive_name(backend.repo_id, backend.repo_name, commit_sha=commit.short_id, ext=extension, path_sha=path_sha)
 
             fname = commit.raw_id + extension
             response = self.app.get(
                 route_path('repo_archivefile',
                            repo_name=backend.repo_name,
                            fname=fname, params={'at_path': at_path}))
 
             assert response.status == '200 OK'
             headers = [
                 ('Content-Disposition', f'attachment; filename={filename}'),
                 ('Content-Type', content_type),
             ]
 
             for header in headers:
                 assert header in list(response.headers.items())
 
     @pytest.mark.parametrize('arch_ext',[
         'tar', 'rar', 'x', '..ax', '.zipz', 'tar.gz.tar'])
     def test_archival_wrong_ext(self, backend, arch_ext):
         backend.enable_downloads()
         commit = backend.repo.get_commit(commit_idx=173)
 
         fname = commit.raw_id + '.' + arch_ext
 
         response = self.app.get(
             route_path('repo_archivefile',
                        repo_name=backend.repo_name,
                        fname=fname))
         response.mustcontain(
             'Unknown archive type for: `{}`'.format(fname))
 
     @pytest.mark.parametrize('commit_id', [
         '00x000000', 'tar', 'wrong', '@$@$42413232', '232dffcd'])
     def test_archival_wrong_commit_id(self, backend, commit_id):
         backend.enable_downloads()
         fname = f'{commit_id}.zip'
 
         response = self.app.get(
             route_path('repo_archivefile',
                        repo_name=backend.repo_name,
                        fname=fname))
         response.mustcontain('Unknown commit_id')
 
 
 @pytest.mark.usefixtures("app")
 class TestFilesDiff(object):
 
     @pytest.mark.parametrize("diff", ['diff', 'download', 'raw'])
     def test_file_full_diff(self, backend, diff):
         commit1 = backend.repo.get_commit(commit_idx=-1)
         commit2 = backend.repo.get_commit(commit_idx=-2)
 
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend.repo_name,
                        f_path='README'),
             params={
                 'diff1': commit2.raw_id,
                 'diff2': commit1.raw_id,
                 'fulldiff': '1',
                 'diff': diff,
             })
 
         if diff == 'diff':
             # use redirect since this is OLD view redirecting to compare page
             response = response.follow()
 
         # It's a symlink to README.rst
         response.mustcontain('README.rst')
         response.mustcontain('No newline at end of file')
 
     def test_file_binary_diff(self, backend):
         commits = [
             {'message': 'First commit'},
             {'message': 'Commit with binary',
              'added': [nodes.FileNode(b'file.bin', content='\0BINARY\0')]},
         ]
         repo = backend.create_repo(commits=commits)
 
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend.repo_name,
                        f_path='file.bin'),
             params={
                 'diff1': repo.get_commit(commit_idx=0).raw_id,
                 'diff2': repo.get_commit(commit_idx=1).raw_id,
                 'fulldiff': '1',
                 'diff': 'diff',
             })
         # use redirect since this is OLD view redirecting to compare page
         response = response.follow()
         response.mustcontain('Collapse 1 commit')
         file_changes = (1, 0, 0)
 
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(*file_changes)
 
         if backend.alias == 'svn':
             response.mustcontain('new file 10644')
             # TODO(marcink): SVN doesn't yet detect binary changes
         else:
             response.mustcontain('new file 100644')
             response.mustcontain('binary diff hidden')
 
     def test_diff_2way(self, backend):
         commit1 = backend.repo.get_commit(commit_idx=-1)
         commit2 = backend.repo.get_commit(commit_idx=-2)
         response = self.app.get(
             route_path('repo_files_diff_2way_redirect',
                        repo_name=backend.repo_name,
                        f_path='README'),
             params={
                 'diff1': commit2.raw_id,
                 'diff2': commit1.raw_id,
             })
         # use redirect since this is OLD view redirecting to compare page
         response = response.follow()
 
         # It's a symlink to README.rst
         response.mustcontain('README.rst')
         response.mustcontain('No newline at end of file')
 
     def test_requires_one_commit_id(self, backend, autologin_user):
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend.repo_name,
                        f_path='README.rst'),
             status=400)
         response.mustcontain(
             'Need query parameter', 'diff1', 'diff2', 'to generate a diff.')
 
     def test_returns_no_files_if_file_does_not_exist(self, vcsbackend):
         repo = vcsbackend.repo
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=repo.name,
                        f_path='does-not-exist-in-any-commit'),
             params={
                 'diff1': repo[0].raw_id,
                 'diff2': repo[1].raw_id
             })
 
         response = response.follow()
         response.mustcontain('No files')
 
     def test_returns_redirect_if_file_not_changed(self, backend):
         commit = backend.repo.get_commit(commit_idx=-1)
         response = self.app.get(
             route_path('repo_files_diff_2way_redirect',
                        repo_name=backend.repo_name,
                        f_path='README'),
             params={
                 'diff1': commit.raw_id,
                 'diff2': commit.raw_id,
             })
 
         response = response.follow()
         response.mustcontain('No files')
         response.mustcontain('No commits in this compare')
 
     def test_supports_diff_to_different_path_svn(self, backend_svn):
         #TODO: check this case
         return
 
         repo = backend_svn['svn-simple-layout'].scm_instance()
         commit_id_1 = '24'
         commit_id_2 = '26'
 
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend_svn.repo_name,
                        f_path='trunk/example.py'),
             params={
                 'diff1': 'tags/v0.2/example.py@' + commit_id_1,
                 'diff2': commit_id_2,
             })
 
         response = response.follow()
         response.mustcontain(
             # diff contains this
             "Will print out a useful message on invocation.")
 
         # Note: Expecting that we indicate the user what's being compared
         response.mustcontain("trunk/example.py")
         response.mustcontain("tags/v0.2/example.py")
 
     def test_show_rev_redirects_to_svn_path(self, backend_svn):
         #TODO: check this case
         return
 
         repo = backend_svn['svn-simple-layout'].scm_instance()
         commit_id = repo[-1].raw_id
 
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend_svn.repo_name,
                        f_path='trunk/example.py'),
             params={
                 'diff1': 'branches/argparse/example.py@' + commit_id,
                 'diff2': commit_id,
             },
             status=302)
         response = response.follow()
         assert response.headers['Location'].endswith(
             'svn-svn-simple-layout/files/26/branches/argparse/example.py')
 
     def test_show_rev_and_annotate_redirects_to_svn_path(self, backend_svn):
         #TODO: check this case
         return
 
         repo = backend_svn['svn-simple-layout'].scm_instance()
         commit_id = repo[-1].raw_id
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend_svn.repo_name,
                        f_path='trunk/example.py'),
             params={
                 'diff1': 'branches/argparse/example.py@' + commit_id,
                 'diff2': commit_id,
                 'show_rev': 'Show at Revision',
                 'annotate': 'true',
             },
             status=302)
         response = response.follow()
         assert response.headers['Location'].endswith(
             'svn-svn-simple-layout/annotate/26/branches/argparse/example.py')
 
 
 @pytest.mark.usefixtures("app", "autologin_user")
 class TestModifyFilesWithWebInterface(object):
 
     def test_add_file_view(self, backend):
         self.app.get(
             route_path('repo_files_add_file',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/')
             )
 
     @pytest.mark.xfail_backends("svn", reason="Depends on online editing")
     def test_add_file_into_repo_missing_content(self, backend, csrf_token):
         backend.create_repo()
         filename = 'init.py'
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'),
             params={
                 'content': "",
                 'filename': filename,
                 'csrf_token': csrf_token,
             },
             status=302)
         expected_msg = 'Successfully committed new file `{}`'.format(os.path.join(filename))
         assert_session_flash(response, expected_msg)
 
     def test_add_file_into_repo_missing_filename(self, backend, csrf_token):
         commit_id = backend.repo.get_commit().raw_id
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=backend.repo_name,
                        commit_id=commit_id, f_path='/'),
             params={
                 'content': "foo",
                 'csrf_token': csrf_token,
             },
             status=302)
 
         assert_session_flash(response, 'No filename specified')
 
     def test_add_file_into_repo_errors_and_no_commits(
             self, backend, csrf_token):
         repo = backend.create_repo()
         # Create a file with no filename, it will display an error but
         # the repo has no commits yet
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'),
             params={
                 'content': "foo",
                 'csrf_token': csrf_token,
             },
             status=302)
 
         assert_session_flash(response, 'No filename specified')
 
         # Not allowed, redirect to the summary
         redirected = response.follow()
         summary_url = h.route_path('repo_summary', repo_name=repo.repo_name)
 
         # As there are no commits, displays the summary page with the error of
         # creating a file with no filename
 
         assert redirected.request.path == summary_url
 
     @pytest.mark.parametrize("filename, clean_filename", [
         ('/abs/foo', 'abs/foo'),
         ('../rel/foo', 'rel/foo'),
         ('file/../foo/foo', 'file/foo/foo'),
     ])
     def test_add_file_into_repo_bad_filenames(self, filename, clean_filename, backend, csrf_token):
         repo = backend.create_repo()
         commit_id = repo.get_commit().raw_id
 
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=repo.repo_name,
                        commit_id=commit_id, f_path='/'),
             params={
                 'content': "foo",
                 'filename': filename,
                 'csrf_token': csrf_token,
             },
             status=302)
 
         expected_msg = 'Successfully committed new file `{}`'.format(clean_filename)
         assert_session_flash(response, expected_msg)
 
     @pytest.mark.parametrize("cnt, filename, content", [
         (1, 'foo.txt', "Content"),
         (2, 'dir/foo.rst', "Content"),
         (3, 'dir/foo-second.rst', "Content"),
         (4, 'rel/dir/foo.bar', "Content"),
     ])
     def test_add_file_into_empty_repo(self, cnt, filename, content, backend, csrf_token):
         repo = backend.create_repo()
         commit_id = repo.get_commit().raw_id
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=repo.repo_name,
                        commit_id=commit_id, f_path='/'),
             params={
                 'content': content,
                 'filename': filename,
                 'csrf_token': csrf_token,
             },
             status=302)
 
         expected_msg = 'Successfully committed new file `{}`'.format(filename)
         assert_session_flash(response, expected_msg)
 
     def test_edit_file_view(self, backend):
         response = self.app.get(
             route_path('repo_files_edit_file',
                        repo_name=backend.repo_name,
                        commit_id=backend.default_head_id,
                        f_path='vcs/nodes.py'),
             status=200)
         response.mustcontain("Module holding everything related to vcs nodes.")
 
     def test_edit_file_view_not_on_branch(self, backend):
         repo = backend.create_repo()
         backend.ensure_file(b"vcs/nodes.py")
 
         response = self.app.get(
             route_path('repo_files_edit_file',
                        repo_name=repo.repo_name,
                        commit_id='tip',
                        f_path='vcs/nodes.py'),
             status=302)
         assert_session_flash(
             response, 'Cannot modify file. Given commit `tip` is not head of a branch.')
 
     def test_edit_file_view_commit_changes(self, backend, csrf_token):
         repo = backend.create_repo()
         backend.ensure_file(b"vcs/nodes.py", content=b"print 'hello'")
 
         response = self.app.post(
             route_path('repo_files_update_file',
                        repo_name=repo.repo_name,
                        commit_id=backend.default_head_id,
                        f_path='vcs/nodes.py'),
             params={
                 'content': "print 'hello world'",
                 'message': 'I committed',
                 'filename': "vcs/nodes.py",
                 'csrf_token': csrf_token,
             },
             status=302)
         assert_session_flash(
             response, 'Successfully committed changes to file `vcs/nodes.py`')
         tip = repo.get_commit(commit_idx=-1)
         assert tip.message == 'I committed'
 
     def test_edit_file_view_commit_changes_default_message(self, backend,
                                                            csrf_token):
         repo = backend.create_repo()
         backend.ensure_file(b"vcs/nodes.py", content=b"print 'hello'")
 
         commit_id = (
             backend.default_branch_name or
             backend.repo.scm_instance().commit_ids[-1])
 
         response = self.app.post(
             route_path('repo_files_update_file',
                        repo_name=repo.repo_name,
                        commit_id=commit_id,
                        f_path='vcs/nodes.py'),
             params={
                 'content': "print 'hello world'",
                 'message': '',
                 'filename': "vcs/nodes.py",
                 'csrf_token': csrf_token,
             },
             status=302)
         assert_session_flash(
             response, 'Successfully committed changes to file `vcs/nodes.py`')
         tip = repo.get_commit(commit_idx=-1)
         assert tip.message == 'Edited file vcs/nodes.py via RhodeCode Enterprise'
 
     def test_delete_file_view(self, backend):
         self.app.get(
             route_path('repo_files_remove_file',
                        repo_name=backend.repo_name,
                        commit_id=backend.default_head_id,
                        f_path='vcs/nodes.py'),
             status=200)
 
     def test_delete_file_view_not_on_branch(self, backend):
         repo = backend.create_repo()
         backend.ensure_file(b'vcs/nodes.py')
 
         response = self.app.get(
             route_path('repo_files_remove_file',
                        repo_name=repo.repo_name,
                        commit_id='tip',
                        f_path='vcs/nodes.py'),
             status=302)
         assert_session_flash(
             response, 'Cannot modify file. Given commit `tip` is not head of a branch.')
 
     def test_delete_file_view_commit_changes(self, backend, csrf_token):
         repo = backend.create_repo()
         backend.ensure_file(b"vcs/nodes.py")
 
         response = self.app.post(
             route_path('repo_files_delete_file',
                        repo_name=repo.repo_name,
                        commit_id=backend.default_head_id,
                        f_path='vcs/nodes.py'),
             params={
                 'message': 'i committed',
                 'csrf_token': csrf_token,
             },
             status=302)
         assert_session_flash(
             response, 'Successfully deleted file `vcs/nodes.py`')
 
 
 @pytest.mark.usefixtures("app")
 class TestFilesViewOtherCases(object):
 
     def test_access_empty_repo_redirect_to_summary_with_alert_write_perms(
             self, backend_stub, autologin_regular_user, user_regular,
             user_util):
 
         repo = backend_stub.create_repo()
         user_util.grant_user_permission_to_repo(
             repo, user_regular, 'repository.write')
         response = self.app.get(
             route_path('repo_files',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'))
 
         repo_file_add_url = route_path(
             'repo_files_add_file',
             repo_name=repo.repo_name,
             commit_id=0, f_path='')
         add_new = f'<a class="alert-link" href="{repo_file_add_url}">add a new file</a>'
 
         repo_file_upload_url = route_path(
             'repo_files_upload_file',
             repo_name=repo.repo_name,
             commit_id=0, f_path='')
         upload_new = f'<a class="alert-link" href="{repo_file_upload_url}">upload a new file</a>'
 
         assert_session_flash(
             response,
             'There are no files yet. Click here to %s or %s.' % (add_new, upload_new)
             )
 
     def test_access_empty_repo_redirect_to_summary_with_alert_no_write_perms(
             self, backend_stub, autologin_regular_user):
         repo = backend_stub.create_repo()
         # init session for anon user
         route_path('repo_summary', repo_name=repo.repo_name)
 
         repo_file_add_url = route_path(
             'repo_files_add_file',
             repo_name=repo.repo_name,
             commit_id=0, f_path='')
 
         response = self.app.get(
             route_path('repo_files',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'))
 
         assert_session_flash(response, no_=repo_file_add_url)
 
     @pytest.mark.parametrize('file_node', [
         b'archive/file.zip',
         b'diff/my-file.txt',
         b'render.py',
         b'render',
         b'remove_file',
         b'remove_file/to-delete.txt',
     ])
     def test_file_names_equal_to_routes_parts(self, backend, file_node):
         backend.create_repo()
         backend.ensure_file(file_node)
 
         self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path=safe_str(file_node)),
             status=200)
 
 
 class TestAdjustFilePathForSvn(object):
     """
     SVN specific adjustments of node history in RepoFilesView.
     """
 
     def test_returns_path_relative_to_matched_reference(self):
         repo = self._repo(branches=['trunk'])
         self.assert_file_adjustment('trunk/file', 'file', repo)
 
     def test_does_not_modify_file_if_no_reference_matches(self):
         repo = self._repo(branches=['trunk'])
         self.assert_file_adjustment('notes/file', 'notes/file', repo)
 
     def test_does_not_adjust_partial_directory_names(self):
         repo = self._repo(branches=['trun'])
         self.assert_file_adjustment('trunk/file', 'trunk/file', repo)
 
     def test_is_robust_to_patterns_which_prefix_other_patterns(self):
         repo = self._repo(branches=['trunk', 'trunk/new', 'trunk/old'])
         self.assert_file_adjustment('trunk/new/file', 'file', repo)
 
     def assert_file_adjustment(self, f_path, expected, repo):
         result = RepoFilesView.adjust_file_path_for_svn(f_path, repo)
         assert result == expected
 
     def _repo(self, branches=None):
         repo = mock.Mock()
         repo.branches = OrderedDict((name, '0') for name in branches or [])
         repo.tags = {}
         return repo

rhodecode/apps/repository/tests/test_repo_forks.py

@@ -1,334 +1,317 b''
 
 # 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 TestController, assert_session_flash, HG_FORK, GIT_FORK
 
 from rhodecode.tests.fixture import Fixture
 from rhodecode.lib import helpers as h
 
 from rhodecode.model.db import Repository
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.meta import Session
-
-fixture = Fixture()
+from rhodecode.tests.routes import route_path
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'repo_summary': '/{repo_name}',
-        'repo_creating_check': '/{repo_name}/repo_creating_check',
-        'repo_fork_new': '/{repo_name}/fork',
-        'repo_fork_create': '/{repo_name}/fork/create',
-        'repo_forks_show_all': '/{repo_name}/forks',
-        'repo_forks_data': '/{repo_name}/forks/data',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+fixture = Fixture()
 
 
 FORK_NAME = {
     'hg': HG_FORK,
     'git': GIT_FORK
 }
 
 
 @pytest.mark.skip_backends('svn')
 class TestRepoForkViewTests(TestController):
 
     def test_show_forks(self, backend, xhr_header):
         self.log_user()
         response = self.app.get(
             route_path('repo_forks_data', repo_name=backend.repo_name),
             extra_environ=xhr_header)
 
         assert response.json == {u'data': [], u'draw': None,
                                  u'recordsFiltered': 0, u'recordsTotal': 0}
 
     def test_no_permissions_to_fork_page(self, backend, user_util):
         user = user_util.create_user(password='qweqwe')
         user_id = user.user_id
         self.log_user(user.username, 'qweqwe')
 
         user_model = UserModel()
         user_model.revoke_perm(user_id, 'hg.fork.repository')
         user_model.grant_perm(user_id, 'hg.fork.none')
         u = UserModel().get(user_id)
         u.inherit_default_permissions = False
         Session().commit()
         # try create a fork
         self.app.get(
             route_path('repo_fork_new', repo_name=backend.repo_name),
             status=404)
 
     def test_no_permissions_to_fork_submit(self, backend, csrf_token, user_util):
         user = user_util.create_user(password='qweqwe')
         user_id = user.user_id
         self.log_user(user.username, 'qweqwe')
 
         user_model = UserModel()
         user_model.revoke_perm(user_id, 'hg.fork.repository')
         user_model.grant_perm(user_id, 'hg.fork.none')
         u = UserModel().get(user_id)
         u.inherit_default_permissions = False
         Session().commit()
         # try create a fork
         self.app.post(
             route_path('repo_fork_create', repo_name=backend.repo_name),
             {'csrf_token': csrf_token},
             status=404)
 
     def test_fork_missing_data(self, autologin_user, backend, csrf_token):
         # try create a fork
         response = self.app.post(
             route_path('repo_fork_create', repo_name=backend.repo_name),
             {'csrf_token': csrf_token},
             status=200)
         # test if html fill works fine
         response.mustcontain('Missing value')
 
     def test_create_fork_page(self, autologin_user, backend):
         self.app.get(
             route_path('repo_fork_new', repo_name=backend.repo_name),
             status=200)
 
     def test_create_and_show_fork(
             self, autologin_user, backend, csrf_token, xhr_header):
 
         # create a fork
         fork_name = FORK_NAME[backend.alias]
         description = 'fork of vcs test'
         repo_name = backend.repo_name
         source_repo = Repository.get_by_repo_name(repo_name)
         creation_args = {
             'repo_name': fork_name,
             'repo_group': '',
             'fork_parent_id': source_repo.repo_id,
             'repo_type': backend.alias,
             'description': description,
             'private': 'False',
             'csrf_token': csrf_token,
         }
 
         self.app.post(
             route_path('repo_fork_create', repo_name=repo_name), creation_args)
 
         response = self.app.get(
             route_path('repo_forks_data', repo_name=repo_name),
             extra_environ=xhr_header)
 
         assert response.json['data'][0]['fork_name'] == \
             """<a href="/%s">%s</a>""" % (fork_name, fork_name)
 
         # remove this fork
         fixture.destroy_repo(fork_name)
 
     def test_fork_create(self, autologin_user, backend, csrf_token):
         fork_name = FORK_NAME[backend.alias]
         description = 'fork of vcs test'
         repo_name = backend.repo_name
         source_repo = Repository.get_by_repo_name(repo_name)
         creation_args = {
             'repo_name': fork_name,
             'repo_group': '',
             'fork_parent_id': source_repo.repo_id,
             'repo_type': backend.alias,
             'description': description,
             'private': 'False',
             'csrf_token': csrf_token,
         }
         self.app.post(
             route_path('repo_fork_create', repo_name=repo_name), creation_args)
         repo = Repository.get_by_repo_name(FORK_NAME[backend.alias])
         assert repo.fork.repo_name == backend.repo_name
 
         # run the check page that triggers the flash message
         response = self.app.get(
             route_path('repo_creating_check', repo_name=fork_name))
         # test if we have a message that fork is ok
         assert_session_flash(response,
                 'Forked repository %s as <a href="/%s">%s</a>' % (
                                  repo_name, fork_name, fork_name))
 
         # test if the fork was created in the database
         fork_repo = Session().query(Repository)\
             .filter(Repository.repo_name == fork_name).one()
 
         assert fork_repo.repo_name == fork_name
         assert fork_repo.fork.repo_name == repo_name
 
         # test if the repository is visible in the list ?
         response = self.app.get(
             h.route_path('repo_summary', repo_name=fork_name))
         response.mustcontain(fork_name)
         response.mustcontain(backend.alias)
         response.mustcontain('Fork of')
         response.mustcontain('<a href="/%s">%s</a>' % (repo_name, repo_name))
 
     def test_fork_create_into_group(self, autologin_user, backend, csrf_token):
         group = fixture.create_repo_group('vc')
         group_id = group.group_id
         fork_name = FORK_NAME[backend.alias]
         fork_name_full = 'vc/%s' % fork_name
         description = 'fork of vcs test'
         repo_name = backend.repo_name
         source_repo = Repository.get_by_repo_name(repo_name)
         creation_args = {
             'repo_name': fork_name,
             'repo_group': group_id,
             'fork_parent_id': source_repo.repo_id,
             'repo_type': backend.alias,
             'description': description,
             'private': 'False',
             'csrf_token': csrf_token,
         }
         self.app.post(
             route_path('repo_fork_create', repo_name=repo_name), creation_args)
         repo = Repository.get_by_repo_name(fork_name_full)
         assert repo.fork.repo_name == backend.repo_name
 
         # run the check page that triggers the flash message
         response = self.app.get(
             route_path('repo_creating_check', repo_name=fork_name_full))
         # test if we have a message that fork is ok
         assert_session_flash(response,
                              'Forked repository %s as <a href="/%s">%s</a>' % (
                                  repo_name, fork_name_full, fork_name_full))
 
         # test if the fork was created in the database
         fork_repo = Session().query(Repository)\
             .filter(Repository.repo_name == fork_name_full).one()
 
         assert fork_repo.repo_name == fork_name_full
         assert fork_repo.fork.repo_name == repo_name
 
         # test if the repository is visible in the list ?
         response = self.app.get(
             h.route_path('repo_summary', repo_name=fork_name_full))
         response.mustcontain(fork_name_full)
         response.mustcontain(backend.alias)
 
         response.mustcontain('Fork of')
         response.mustcontain('<a href="/%s">%s</a>' % (repo_name, repo_name))
 
         fixture.destroy_repo(fork_name_full)
         fixture.destroy_repo_group(group_id)
 
     def test_fork_read_permission(self, backend, xhr_header, user_util):
         user = user_util.create_user(password='qweqwe')
         user_id = user.user_id
         self.log_user(user.username, 'qweqwe')
 
         # create a fake fork
         fork = user_util.create_repo(repo_type=backend.alias)
         source = user_util.create_repo(repo_type=backend.alias)
         repo_name = source.repo_name
 
         fork.fork_id = source.repo_id
         fork_name = fork.repo_name
         Session().commit()
 
         forks = Repository.query()\
             .filter(Repository.repo_type == backend.alias)\
             .filter(Repository.fork_id == source.repo_id).all()
         assert 1 == len(forks)
 
         # set read permissions for this
         RepoModel().grant_user_permission(
             repo=forks[0], user=user_id, perm='repository.read')
         Session().commit()
 
         response = self.app.get(
             route_path('repo_forks_data', repo_name=repo_name),
             extra_environ=xhr_header)
 
         assert response.json['data'][0]['fork_name'] == \
             """<a href="/%s">%s</a>""" % (fork_name, fork_name)
 
     def test_fork_none_permission(self, backend, xhr_header, user_util):
         user = user_util.create_user(password='qweqwe')
         user_id = user.user_id
         self.log_user(user.username, 'qweqwe')
 
         # create a fake fork
         fork = user_util.create_repo(repo_type=backend.alias)
         source = user_util.create_repo(repo_type=backend.alias)
         repo_name = source.repo_name
 
         fork.fork_id = source.repo_id
 
         Session().commit()
 
         forks = Repository.query()\
             .filter(Repository.repo_type == backend.alias)\
             .filter(Repository.fork_id == source.repo_id).all()
         assert 1 == len(forks)
 
         # set none
         RepoModel().grant_user_permission(
             repo=forks[0], user=user_id, perm='repository.none')
         Session().commit()
 
         # fork shouldn't be there
         response = self.app.get(
             route_path('repo_forks_data', repo_name=repo_name),
             extra_environ=xhr_header)
 
         assert response.json == {u'data': [], u'draw': None,
                                  u'recordsFiltered': 0, u'recordsTotal': 0}
 
     @pytest.mark.parametrize('url_type', [
         'repo_fork_new',
         'repo_fork_create'
     ])
     def test_fork_is_forbidden_on_archived_repo(self, backend, xhr_header, user_util, url_type):
         user = user_util.create_user(password='qweqwe')
         self.log_user(user.username, 'qweqwe')
 
         # create a temporary repo
         source = user_util.create_repo(repo_type=backend.alias)
         repo_name = source.repo_name
         repo = Repository.get_by_repo_name(repo_name)
         repo.archived = True
         Session().commit()
 
         response = self.app.get(
             route_path(url_type, repo_name=repo_name), status=302)
 
         msg = 'Action not supported for archived repository.'
         assert_session_flash(response, msg)
 
 
 class TestSVNFork(TestController):
     @pytest.mark.parametrize('route_name', [
         'repo_fork_create', 'repo_fork_new'
     ])
     def test_fork_redirects(self, autologin_user, backend_svn, route_name):
 
         self.app.get(route_path(
             route_name, repo_name=backend_svn.repo_name),
             status=404)

rhodecode/apps/repository/tests/test_repo_issue_tracker.py

@@ -1,150 +1,134 b''
 
 # 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.hash_utils import md5_safe
 from rhodecode.model.db import Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel, IssueTrackerSettingsModel
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
+from rhodecode.tests.routes import route_path
 
-    base_url = {
-        'repo_summary': '/{repo_name}',
-        'edit_repo_issuetracker': '/{repo_name}/settings/issue_trackers',
-        'edit_repo_issuetracker_test': '/{repo_name}/settings/issue_trackers/test',
-        'edit_repo_issuetracker_delete': '/{repo_name}/settings/issue_trackers/delete',
-        'edit_repo_issuetracker_update': '/{repo_name}/settings/issue_trackers/update',
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
 
 
 @pytest.mark.usefixtures("app")
 class TestRepoIssueTracker(object):
     def test_issuetracker_index(self, autologin_user, backend):
         repo = backend.create_repo()
         response = self.app.get(route_path('edit_repo_issuetracker',
                                 repo_name=repo.repo_name))
         assert response.status_code == 200
 
     def test_add_and_test_issuetracker_patterns(
             self, autologin_user, backend, csrf_token, request, xhr_header):
         pattern = 'issuetracker_pat'
         another_pattern = pattern+'1'
         post_url = route_path(
             'edit_repo_issuetracker_update', repo_name=backend.repo.repo_name)
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'http://url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
             'new_pattern_pattern_1': another_pattern,
             'new_pattern_url_1': '/url1',
             'new_pattern_prefix_1': 'prefix1',
             'new_pattern_description_1': 'description1',
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         self.settings_model = IssueTrackerSettingsModel(repo=backend.repo)
         settings = self.settings_model.get_repo_settings()
         self.uid = md5_safe(pattern)
         assert settings[self.uid]['pat'] == pattern
         self.another_uid = md5_safe(another_pattern)
         assert settings[self.another_uid]['pat'] == another_pattern
 
         # test pattern
         data = {'test_text': 'example of issuetracker_pat replacement',
                 'csrf_token': csrf_token}
         response = self.app.post(
             route_path('edit_repo_issuetracker_test',
                        repo_name=backend.repo.repo_name),
             extra_environ=xhr_header, params=data)
 
         assert response.text == \
                'example of <a class="tooltip issue-tracker-link" href="http://url" title="description">prefix</a> replacement'
 
         @request.addfinalizer
         def cleanup():
             self.settings_model.delete_entries(self.uid)
             self.settings_model.delete_entries(self.another_uid)
 
     def test_edit_issuetracker_pattern(
             self, autologin_user, backend, csrf_token, request):
         entry_key = 'issuetracker_pat_'
         pattern = 'issuetracker_pat2'
         old_pattern = 'issuetracker_pat'
         old_uid = md5_safe(old_pattern)
 
         sett = SettingsModel(repo=backend.repo).create_or_update_setting(
             entry_key+old_uid, old_pattern, 'unicode')
         Session().add(sett)
         Session().commit()
         post_url = route_path(
             'edit_repo_issuetracker_update', repo_name=backend.repo.repo_name)
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': '/url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
             'uid': old_uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         self.settings_model = IssueTrackerSettingsModel(repo=backend.repo)
         settings = self.settings_model.get_repo_settings()
         self.uid = md5_safe(pattern)
         assert settings[self.uid]['pat'] == pattern
         with pytest.raises(KeyError):
             key = settings[old_uid]
 
         @request.addfinalizer
         def cleanup():
             self.settings_model.delete_entries(self.uid)
 
     def test_delete_issuetracker_pattern(
             self, autologin_user, backend, csrf_token, settings_util, xhr_header):
         repo = backend.create_repo()
         repo_name = repo.repo_name
         entry_key = 'issuetracker_pat_'
         pattern = 'issuetracker_pat3'
         uid = md5_safe(pattern)
         settings_util.create_repo_rhodecode_setting(
             repo=backend.repo, name=entry_key+uid,
             value=entry_key, type_='unicode', cleanup=False)
 
         self.app.post(
             route_path(
                 'edit_repo_issuetracker_delete',
                 repo_name=backend.repo.repo_name),
             {
                 'uid': uid,
                 'csrf_token': csrf_token,
                 '': ''
             }, extra_environ=xhr_header, status=200)
         settings = IssueTrackerSettingsModel(
             repo=Repository.get_by_repo_name(repo_name)).get_repo_settings()
         assert 'rhodecode_%s%s' % (entry_key, uid) not in settings

rhodecode/apps/repository/tests/test_repo_maintainance.py

@@ -1,75 +1,55 b''
 
 # 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.utils2 import str2bool
-from rhodecode.lib.vcs.exceptions import RepositoryRequirementError
 from rhodecode.model.db import Repository, UserRepoToPerm, Permission, User
-from rhodecode.model.meta import Session
-from rhodecode.tests import (
-    TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, assert_session_flash)
+
 from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.routes import route_path
 
 fixture = Fixture()
 
 
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'edit_repo_maintenance': '/{repo_name}/settings/maintenance',
-        'edit_repo_maintenance_execute': '/{repo_name}/settings/maintenance/execute',
-
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
-
-
 def _get_permission_for_user(user, repo):
     perm = UserRepoToPerm.query()\
         .filter(UserRepoToPerm.repository ==
                 Repository.get_by_repo_name(repo))\
         .filter(UserRepoToPerm.user == User.get_by_username(user))\
         .all()
     return perm
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminRepoMaintenance(object):
     @pytest.mark.parametrize('urlname', [
         'edit_repo_maintenance',
     ])
     def test_show_page(self, urlname, app, backend):
         app.get(route_path(urlname, repo_name=backend.repo_name), status=200)
 
     def test_execute_maintenance_for_repo_hg(self, app, backend_hg, autologin_user, xhr_header):
         repo_name = backend_hg.repo_name
 
         response = app.get(
             route_path('edit_repo_maintenance_execute',
                        repo_name=repo_name,),
             extra_environ=xhr_header)
 
         assert "HG Verify repo" in ''.join(response.json)

rhodecode/apps/repository/tests/test_repo_permissions.py

@@ -1,78 +1,64 b''
 
 # 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.utils import permission_update_data_generator
-
-
-def route_path(name, params=None, **kwargs):
-    import urllib.request
-    import urllib.parse
-    import urllib.error
-
-    base_url = {
-        'edit_repo_perms': '/{repo_name}/settings/permissions'
-        # update is the same url
-    }[name].format(**kwargs)
-
-    if params:
-        base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
-    return base_url
+from rhodecode.tests.routes import route_path
 
 
 @pytest.mark.usefixtures("app")
 class TestRepoPermissionsView(object):
 
     def test_edit_perms_view(self, user_util, autologin_user):
         repo = user_util.create_repo()
         self.app.get(
             route_path('edit_repo_perms',
                        repo_name=repo.repo_name), status=200)
 
     def test_update_permissions(self, csrf_token, user_util):
         repo = user_util.create_repo()
         repo_name = repo.repo_name
         user = user_util.create_user()
         user_id = user.user_id
         username = user.username
 
         # grant new
         form_data = permission_update_data_generator(
             csrf_token,
             default='repository.write',
             grant=[(user_id, 'repository.write', username, 'user')])
 
         response = self.app.post(
             route_path('edit_repo_perms',
                        repo_name=repo_name), form_data).follow()
 
         assert 'Repository access permissions updated' in response
 
         # revoke given
         form_data = permission_update_data_generator(
             csrf_token,
             default='repository.read',
             revoke=[(user_id, 'user')])
 
         response = self.app.post(
             route_path('edit_repo_perms',
                        repo_name=repo_name), form_data).follow()
 
         assert 'Repository access permissions updated' in response