tests: fixed test suite for celery adoption

rhodecode/lib/hook_daemon/utils.py

@@ -0,0 +1,61 b''
+# Copyright (C) 2010-2024 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 time
+import logging
+
+from rhodecode.lib.config_utils import get_app_config_lightweight
+
+from rhodecode.lib.hook_daemon.base import Hooks
+from rhodecode.lib.hook_daemon.hook_module import HooksModuleCallbackDaemon
+from rhodecode.lib.hook_daemon.celery_hooks_deamon import CeleryHooksCallbackDaemon
+from rhodecode.lib.type_utils import str2bool
+
+log = logging.getLogger(__name__)
+
+
+
+def prepare_callback_daemon(extras, protocol: str, txn_id=None):
+    hooks_config = {}
+    match protocol:
+        case 'celery':
+            config = get_app_config_lightweight(extras['config'])
+
+            broker_url = config.get('celery.broker_url')
+            result_backend = config.get('celery.result_backend')
+
+            hooks_config = {
+                'broker_url': broker_url,
+                'result_backend': result_backend,
+            }
+
+            callback_daemon = CeleryHooksCallbackDaemon(broker_url, result_backend)
+        case 'local':
+            callback_daemon = HooksModuleCallbackDaemon(Hooks.__module__)
+        case _:
+            log.error('Unsupported callback daemon protocol "%s"', protocol)
+            raise Exception('Unsupported callback daemon protocol.')
+
+    extras['hooks_config'] = hooks_config
+    extras['hooks_protocol'] = protocol
+    extras['time'] = time.time()
+
+    # register txn_id
+    extras['txn_id'] = txn_id
+    log.debug('Prepared a callback daemon: %s', callback_daemon.__class__.__name__)
+    return callback_daemon, extras

rhodecode/tests/database/__init__.py

@@ -0,0 +1,17 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/

rhodecode/tests/fixtures/function_scoped_baseapp.py

@@ -0,0 +1,52 b''
+# Copyright (C) 2010-2024 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 CustomTestApp
+from rhodecode.tests.fixtures.fixture_utils import plain_http_environ, plain_config_stub, plain_request_stub
+
+
[e-mail](scope='function')
+def request_stub():
+    return plain_request_stub()
+
+
[e-mail](scope='function')
+def config_stub(request, request_stub):
+    return plain_config_stub(request, request_stub)
+
+
[e-mail](scope='function')
+def http_environ():
+    """
+    HTTP extra environ keys.
+
+    Used by the test application and as well for setting up the pylons
+    environment. In the case of the fixture "app" it should be possible
+    to override this for a specific test case.
+    """
+    return plain_http_environ()
+
+
[e-mail](scope='function')
+def app(request, config_stub, http_environ, baseapp):
+    app = CustomTestApp(baseapp, extra_environ=http_environ)
+    if request.cls:
+        # inject app into a class that uses this fixtures
+        request.cls.app = app
+    return app

rhodecode/tests/fixtures/module_scoped_baseapp.py

@@ -0,0 +1,49 b''
+# Copyright (C) 2010-2024 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 CustomTestApp
+from rhodecode.tests.fixtures.fixture_utils import plain_http_environ, plain_config_stub, plain_request_stub
+
+
[e-mail](scope='module')
+def module_request_stub():
+    return plain_request_stub()
+
+
[e-mail](scope='module')
+def module_config_stub(request, module_request_stub):
+    return plain_config_stub(request, module_request_stub)
+
+
[e-mail](scope='module')
+def module_http_environ():
+    """
+    HTTP extra environ keys.
+
+    Used by the test application and as well for setting up the pylons
+    environment. In the case of the fixture "app" it should be possible
+    to override this for a specific test case.
+    """
+    return plain_http_environ()
+
+
[e-mail](scope='module')
+def module_app(request, module_config_stub, module_http_environ, baseapp):
+    app = CustomTestApp(baseapp, extra_environ=module_http_environ)
+    return app

rhodecode/tests/fixtures/rcextensions_fixtures.py

@@ -0,0 +1,157 b''
+# Copyright (C) 2010-2024 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 shutil
+import logging
+import textwrap
+
+import pytest
+
+import rhodecode
+import rhodecode.lib
+
+from rhodecode.tests import console_printer
+
+log = logging.getLogger(__name__)
+
+
+def store_rcextensions(destination, force=False):
+    from rhodecode.config import rcextensions
+    package_path = rcextensions.__path__[0]
+
+    # Note: rcextensions are looked up based on the path of the ini file
+    rcextensions_path = os.path.join(destination, 'rcextensions')
+
+    if force:
+        shutil.rmtree(rcextensions_path, ignore_errors=True)
+    shutil.copytree(package_path, rcextensions_path)
+
+
[e-mail](scope="module")
+def rcextensions(request, tmp_storage_location):
+    """
+    Installs a testing rcextensions pack to ensure they work as expected.
+    """
+
+    # Note: rcextensions are looked up based on the path of the ini file
+    rcextensions_path = os.path.join(tmp_storage_location, 'rcextensions')
+
+    if os.path.exists(rcextensions_path):
+        pytest.fail(
+            f"Path for rcextensions already exists, please clean up before "
+            f"test run this path: {rcextensions_path}")
+    else:
+        store_rcextensions(tmp_storage_location)
+
+
[e-mail](scope='function')
+def rcextensions_present(request):
+
+    class RcExtensionsPresent:
+        def __init__(self, rcextensions_location):
+            self.rcextensions_location = rcextensions_location
+
+        def __enter__(self):
+            self.store()
+
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            self.cleanup()
+
+        def store(self):
+            store_rcextensions(self.rcextensions_location)
+
+        def cleanup(self):
+            shutil.rmtree(os.path.join(self.rcextensions_location, 'rcextensions'))
+
+    return RcExtensionsPresent
+
+
[e-mail](scope='function')
+def rcextensions_modification(request):
+    """
+    example usage::
+
+        hook_name = '_pre_push_hook'
+        code = '''
+        raise OSError('failed')
+        return HookResponse(1, 'FAILED')
+        '''
+        mods = [
+            (hook_name, code),
+        ]
+        # rhodecode.ini file location, where rcextensions needs to live
+        rcstack_location = os.path.dirname(rcstack.config_file)
+        with rcextensions_modification(rcstack_location, mods):
+            # do some stuff
+    """
+
+    class RcextensionsModification:
+        def __init__(self, rcextensions_location, mods, create_if_missing=False, force_create=False):
+            self.force_create = force_create
+            self.create_if_missing = create_if_missing
+            self.rcextensions_location = rcextensions_location
+            self.mods = mods
+            if not isinstance(mods, list):
+                raise ValueError('mods must be a list of modifications')
+
+        def __enter__(self):
+            if self.create_if_missing:
+                store_rcextensions(self.rcextensions_location, force=self.force_create)
+
+            for hook_name, method_body in self.mods:
+                self.modification(hook_name, method_body)
+
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            self.cleanup()
+
+        def cleanup(self):
+            # reset rcextensions to "bare" state from the package
+            store_rcextensions(self.rcextensions_location, force=True)
+
+        def modification(self, hook_name, method_body):
+            import ast
+
+            rcextensions_path = os.path.join(self.rcextensions_location, 'rcextensions')
+
+            # Load the code from hooks.py
+            hooks_filename = os.path.join(rcextensions_path, 'hooks.py')
+            with open(hooks_filename, "r") as file:
+                tree = ast.parse(file.read())
+
+            # Define new content for the function as a string
+            new_code = textwrap.dedent(method_body)
+
+            # Parse the new code to add it to the function
+            new_body = ast.parse(new_code).body
+
+            # Walk through the AST to find and modify the function
+            for node in tree.body:
+                if isinstance(node, ast.FunctionDef) and node.name == hook_name:
+                    node.body = new_body  # Replace the function body with the new body
+
+            # Compile the modified AST back to code
+            compile(tree, hooks_filename, "exec")
+
+            # Write the updated code back to hooks.py
+            with open(hooks_filename, "w") as file:
+                file.write(ast.unparse(tree))  # Requires Python 3.9+
+
+            console_printer(f" [green]rcextensions[/green] Updated the body of '{hooks_filename}' function '{hook_name}'")
+
+    return RcextensionsModification

rhodecode/tests/integrations/__init__.py

@@ -0,0 +1,17 b''
+# Copyright (C) 2010-2024 RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/

rhodecode/tests/lib/auth_modules/__init__.py

@@ -0,0 +1,17 b''
+# Copyright (C) 2010-2024 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/

conftest.py

@@ -27,8 +27,11 b' from rhodecode.tests.conftest_common imp'
 
 
 pytest_plugins = [
-    "rhodecode.tests.fixture_mods.fixture_pyramid",
-    "rhodecode.tests.fixture_mods.fixture_utils",
+    "rhodecode.tests.fixtures.fixture_pyramid",
+    "rhodecode.tests.fixtures.fixture_utils",
+    "rhodecode.tests.fixtures.function_scoped_baseapp",
+    "rhodecode.tests.fixtures.module_scoped_baseapp",
+    "rhodecode.tests.fixtures.rcextensions_fixtures",
 ]
 
 

pyproject.toml

@@ -65,8 +65,7 b' dependencies = {file = ["requirements.tx'
 optional-dependencies.tests = {file = ["requirements_test.txt"]}
 
 [tool.ruff]
-
-select = [
+lint.select = [
     # Pyflakes
     "F",
     # Pycodestyle
@@ -75,16 +74,13 b' select = ['
     # isort
     "I001"
 ]
-
-ignore = [
+lint.ignore = [
     "E501",  # line too long, handled by black
 ]
-
 # Same as Black.
 line-length = 120
 
-[tool.ruff.isort]
-
+[tool.ruff.lint.isort]
 known-first-party = ["rhodecode"]
 
 [tool.ruff.format]

pytest.ini

@@ -4,8 +4,10 b' norecursedirs = rhodecode/public rhodeco'
 cache_dir = /tmp/.pytest_cache
 
 pyramid_config = rhodecode/tests/rhodecode.ini
-vcsserver_protocol = http
-vcsserver_config_http = rhodecode/tests/vcsserver_http.ini
+
+vcsserver_config = rhodecode/tests/vcsserver_http.ini
+rhodecode_config = rhodecode/tests/rhodecode.ini
+celery_config = rhodecode/tests/rhodecode.ini
 
 addopts =
   --pdbcls=IPython.terminal.debugger:TerminalPdb

rhodecode/api/tests/test_add_field_to_repo.py

@@ -1,5 +1,4 b''
-
-# Copyright (C) 2010-2023 RhodeCode GmbH
+# Copyright (C) 2010-2024 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

rhodecode/api/tests/test_create_gist.py

@@ -24,7 +24,7 b' from rhodecode.model.db import Gist'
 from rhodecode.model.gist import GistModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 
 
 @pytest.mark.usefixtures("testuser_api", "app")

rhodecode/api/tests/test_create_repo.py

@@ -27,7 +27,7 b' from rhodecode.model.user import UserMod'
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.str_utils import safe_str
 

rhodecode/api/tests/test_create_repo_group.py

@@ -26,7 +26,7 b' from rhodecode.model.user import UserMod'
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 
 
 fixture = Fixture()

rhodecode/api/tests/test_create_user.py

@@ -26,7 +26,7 b' from rhodecode.tests import ('
     TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_EMAIL)
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, jsonify, crash)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.model.db import RepoGroup
 
 

rhodecode/api/tests/test_create_user_group.py

@@ -25,7 +25,7 b' from rhodecode.model.user import UserMod'
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash, jsonify)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 
 
 @pytest.mark.usefixtures("testuser_api", "app")

rhodecode/api/tests/test_fork_repo.py

@@ -28,7 +28,7 b' from rhodecode.model.user import UserMod'
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 
 
 fixture = Fixture()

rhodecode/api/tests/test_update_repo.py

@@ -25,8 +25,8 b' from rhodecode.model.scm import ScmModel'
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash, jsonify)
-from rhodecode.tests.fixture import Fixture
-from rhodecode.tests.fixture_mods.fixture_utils import plain_http_host_only_stub
+from rhodecode.tests.fixtures.rc_fixture import Fixture
+from rhodecode.tests.fixtures.fixture_utils import plain_http_host_only_stub
 
 fixture = Fixture()
 

rhodecode/apps/admin/tests/test_admin_audit_logs.py

@@ -26,7 +26,7 b' 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.tests.fixtures.rc_fixture import FIXTURES
 from rhodecode.model.db import UserLog
 from rhodecode.model.meta import Session
 

rhodecode/apps/admin/tests/test_admin_main_views.py

@@ -20,7 +20,7 b''
 import pytest
 
 from rhodecode.tests import TestController
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/admin/tests/test_admin_repos.py

@@ -37,7 +37,7 b' from rhodecode.model.user import UserMod'
 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.fixtures.rc_fixture import Fixture, error_function
 from rhodecode.tests.utils import repo_on_filesystem
 from rhodecode.tests.routes import route_path
 

rhodecode/apps/admin/tests/test_admin_repository_groups.py

@@ -27,7 +27,7 b' 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
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 

rhodecode/apps/admin/tests/test_admin_user_groups.py

@@ -24,7 +24,7 b' from rhodecode.model.meta import Session'
 
 from rhodecode.tests import (
     TestController, assert_session_flash)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/admin/tests/test_admin_users.py

@@ -28,7 +28,7 b' from rhodecode.model.user import UserMod'
 
 from rhodecode.tests import (
     TestController, TEST_USER_REGULAR_LOGIN, assert_session_flash)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/admin/tests/test_admin_users_ssh_keys.py

@@ -22,7 +22,7 b' 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.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/home/tests/test_get_goto_switched_data.py

@@ -27,7 +27,7 b' from rhodecode.model.repo_group import R'
 from rhodecode.model.db import Session, Repository, RepoGroup
 
 from rhodecode.tests import TestController, TEST_USER_ADMIN_LOGIN
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/home/tests/test_get_repo_list_data.py

@@ -22,7 +22,7 b' from rhodecode.model.db import Repositor'
 from rhodecode.lib.ext_json import json
 
 from rhodecode.tests import TestController
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/home/tests/test_get_user_data.py

@@ -20,7 +20,7 b' import pytest'
 from rhodecode.lib.ext_json import json
 
 from rhodecode.tests import TestController
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/home/tests/test_get_user_group_data.py

@@ -40,7 +40,7 b' import pytest'
 from rhodecode.lib.ext_json import json
 
 from rhodecode.tests import TestController
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/home/tests/test_home.py

@@ -24,7 +24,7 b' from rhodecode.model.db import Repositor'
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel
 from rhodecode.tests import TestController
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 

rhodecode/apps/login/tests/test_2fa.py

@@ -3,7 +3,7 b' import mock'
 
 from rhodecode.lib.type_utils import AttributeDict
 from rhodecode.model.meta import Session
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 from rhodecode.model.settings import SettingsModel
 

rhodecode/apps/login/tests/test_login.py

@@ -31,7 +31,7 b' 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.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/login/tests/test_password_reset.py

@@ -22,7 +22,7 b' 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.fixtures.rc_fixture import Fixture
 from rhodecode.tests.utils import AssertResponse
 from rhodecode.tests.routes import route_path
 

rhodecode/apps/my_account/tests/test_my_account_auth_tokens.py

@@ -22,7 +22,7 b' from rhodecode.apps._base import ADMIN_P'
 from rhodecode.model.db import User
 from rhodecode.tests import (
     TestController, assert_session_flash)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 

rhodecode/apps/my_account/tests/test_my_account_emails.py

@@ -23,7 +23,7 b' from rhodecode.model.db import User, Use'
 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
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 

rhodecode/apps/my_account/tests/test_my_account_notifications.py

@@ -21,7 +21,7 b' import pytest'
 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.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 from rhodecode.model.db import Notification, User

rhodecode/apps/my_account/tests/test_my_account_password.py

@@ -24,7 +24,7 b' from rhodecode.lib.auth import check_pas'
 from rhodecode.model.meta import Session
 from rhodecode.model.user import UserModel
 from rhodecode.tests import assert_session_flash, TestController
-from rhodecode.tests.fixture import Fixture, error_function
+from rhodecode.tests.fixtures.rc_fixture import Fixture, error_function
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/my_account/tests/test_my_account_profile.py

@@ -20,7 +20,7 b''
 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.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/my_account/tests/test_my_account_simple_views.py

@@ -19,7 +19,7 b''
 
 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.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/my_account/tests/test_my_account_ssh_keys.py

@@ -21,7 +21,7 b''
 from rhodecode.model.db import User, UserSshKeys
 
 from rhodecode.tests import TestController, assert_session_flash
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/repository/tests/test_repo_compare_on_single_file.py

@@ -22,7 +22,7 b' 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.fixtures.rc_fixture import Fixture
 from rhodecode.tests.utils import commit_change
 from rhodecode.tests.routes import route_path
 
@@ -166,14 +166,15 b' class TestSideBySideDiff(object):'
         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'r{commit1.idx}:{commit1.short_id}...r{commit2.idx}:{commit2.short_id}')
 
         response.mustcontain(f_path)
 
-    @pytest.mark.xfail(reason='GIT does not handle empty commit compare correct (missing 1 commit)')
+    #@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):
+        if backend.alias == 'git':
+            pytest.skip('GIT does not handle empty commit compare correct (missing 1 commit)')
+
         f_path = b'test_sidebyside_file.py'
         commit1_content = b'content-25d7e49c18b159446c\n'
         commit2_content = b'content-603d6c72c46d953420\n'
@@ -200,9 +201,7 b' class TestSideBySideDiff(object):'
         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'r{commit1.idx}:{commit1.short_id}...r{commit2.idx}:{commit2.short_id}')
 
         response.mustcontain(f_path)
 

rhodecode/apps/repository/tests/test_repo_files.py

@@ -33,7 +33,7 b' from rhodecode.lib.vcs.conf import setti'
 from rhodecode.model.db import Session, Repository
 
 from rhodecode.tests import assert_session_flash
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 

rhodecode/apps/repository/tests/test_repo_forks.py

@@ -21,7 +21,7 b' import pytest'
 
 from rhodecode.tests import TestController, assert_session_flash, HG_FORK, GIT_FORK
 
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.lib import helpers as h
 
 from rhodecode.model.db import Repository

rhodecode/apps/repository/tests/test_repo_maintainance.py

@@ -21,7 +21,7 b' import pytest'
 
 from rhodecode.model.db import Repository, UserRepoToPerm, Permission, User
 
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/repository/tests/test_repo_pullrequests.py

@@ -15,6 +15,9 b''
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
+import logging
+import os
+
 import mock
 import pytest
 
@@ -41,7 +44,7 b' from rhodecode.tests import ('
     TEST_USER_ADMIN_LOGIN,
     TEST_USER_REGULAR_LOGIN,
 )
-from rhodecode.tests.fixture_mods.fixture_utils import PRTestUtility
+from rhodecode.tests.fixtures.fixture_utils import PRTestUtility
 from rhodecode.tests.routes import route_path
 
 
@@ -1050,7 +1053,6 b' class TestPullrequestsView(object):'
         )
         assert len(notifications.all()) == 2
 
-    @pytest.mark.xfail(reason="unable to fix this test after python3 migration")
     def test_create_pull_request_stores_ancestor_commit_id(self, backend, csrf_token):
         commits = [
             {
@@ -1125,20 +1127,38 b' class TestPullrequestsView(object):'
         response.mustcontain(no=["content_of_ancestor-child"])
         response.mustcontain("content_of_change")
 
-    def test_merge_pull_request_enabled(self, pr_util, csrf_token):
-        # Clear any previous calls to rcextensions
-        rhodecode.EXTENSIONS.calls.clear()
+    def test_merge_pull_request_enabled(self, pr_util, csrf_token, rcextensions_modification):
 
         pull_request = pr_util.create_pull_request(approved=True, mergeable=True)
         pull_request_id = pull_request.pull_request_id
-        repo_name = (pull_request.target_repo.scm_instance().name,)
+        repo_name = pull_request.target_repo.scm_instance().name
 
         url = route_path(
             "pullrequest_merge",
-            repo_name=str(repo_name[0]),
+            repo_name=repo_name,
             pull_request_id=pull_request_id,
         )
-        response = self.app.post(url, params={"csrf_token": csrf_token}).follow()
+
+        rcstack_location = os.path.dirname(self.app._pyramid_registry.settings['__file__'])
+        rc_ext_location = os.path.join(rcstack_location, 'rcextension-output.txt')
+
+
+        mods = [
+            ('_push_hook',
+             f"""
+             import os
+             action = kwargs['action']
+             commit_ids = kwargs['commit_ids']
+             with open('{rc_ext_location}', 'w') as f:
+                 f.write('test-execution'+os.linesep)
+                 f.write(f'{{action}}'+os.linesep)
+                 f.write(f'{{commit_ids}}'+os.linesep)
+             return HookResponse(0, 'HOOK_TEST')
+            """)
+        ]
+        # Add the hook
+        with rcextensions_modification(rcstack_location, mods, create_if_missing=True, force_create=True):
+            response = self.app.post(url, params={"csrf_token": csrf_token}).follow()
 
         pull_request = PullRequest.get(pull_request_id)
 
@@ -1162,12 +1182,39 b' class TestPullrequestsView(object):'
         assert actions[-1].action == "user.push"
         assert actions[-1].action_data["commit_ids"] == pr_commit_ids
 
-        # Check post_push rcextension was really executed
-        push_calls = rhodecode.EXTENSIONS.calls["_push_hook"]
-        assert len(push_calls) == 1
-        unused_last_call_args, last_call_kwargs = push_calls[0]
-        assert last_call_kwargs["action"] == "push"
-        assert last_call_kwargs["commit_ids"] == pr_commit_ids
+        with open(rc_ext_location) as f:
+            f_data = f.read()
+            assert 'test-execution' in f_data
+            for commit_id in pr_commit_ids:
+                assert f'{commit_id}' in f_data
+
+    def test_merge_pull_request_forbidden_by_pre_push_hook(self, pr_util, csrf_token, rcextensions_modification, caplog):
+        caplog.set_level(logging.WARNING, logger="rhodecode.model.pull_request")
+
+        pull_request = pr_util.create_pull_request(approved=True, mergeable=True)
+        pull_request_id = pull_request.pull_request_id
+        repo_name = pull_request.target_repo.scm_instance().name
+
+        url = route_path(
+            "pullrequest_merge",
+            repo_name=repo_name,
+            pull_request_id=pull_request_id,
+        )
+
+        rcstack_location = os.path.dirname(self.app._pyramid_registry.settings['__file__'])
+
+        mods = [
+            ('_pre_push_hook',
+             f"""
+             return HookResponse(1, 'HOOK_TEST_FORBIDDEN')
+            """)
+        ]
+        # Add the hook
+        with rcextensions_modification(rcstack_location, mods, create_if_missing=True, force_create=True):
+            self.app.post(url, params={"csrf_token": csrf_token})
+
+        assert 'Merge failed, not updating the pull request.' in [r[2] for r in caplog.record_tuples]
+
 
     def test_merge_pull_request_disabled(self, pr_util, csrf_token):
         pull_request = pr_util.create_pull_request(mergeable=False)
@@ -1523,7 +1570,6 b' class TestPullrequestsView(object):'
 
         assert pull_request.revisions == [commit_ids["change-rebased"]]
 
-
     def test_remove_pull_request_branch(self, backend_git, csrf_token):
         branch_name = "development"
         commits = [

rhodecode/apps/repository/tests/test_repo_settings.py

@@ -26,7 +26,7 b' from rhodecode.model.db import Repositor'
 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.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/repository/tests/test_repo_settings_advanced.py

@@ -24,7 +24,7 b' from rhodecode.model.db import Repositor'
 from rhodecode.model.repo import RepoModel
 from rhodecode.tests import (
     HG_REPO, GIT_REPO, assert_session_flash, no_newline_id_generator)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.utils import repo_on_filesystem
 from rhodecode.tests.routes import route_path
 

rhodecode/apps/repository/tests/test_repo_summary.py

@@ -31,7 +31,7 b' from rhodecode.model.meta import Session'
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.scm import ScmModel
 from rhodecode.tests import assert_session_flash
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.utils import AssertResponse, repo_on_filesystem
 from rhodecode.tests.routes import route_path
 

rhodecode/apps/repository/tests/test_repo_vcs_settings.py

@@ -30,7 +30,7 b' from rhodecode.model.user import UserMod'
 from rhodecode.tests import (
     login_user_session, logout_user_session,
     TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.utils import AssertResponse
 from rhodecode.tests.routes import route_path
 

rhodecode/apps/repository/tests/test_vcs_settings.py

@@ -32,16 +32,13 b' class TestAdminRepoVcsSettings(object):'
     @pytest.mark.parametrize('setting_name, setting_backends', [
         ('hg_use_rebase_for_merging', ['hg']),
     ])
-    def test_labs_settings_visible_if_enabled(
-            self, setting_name, setting_backends, backend):
+    def test_labs_settings_visible_if_enabled(self, setting_name, setting_backends, backend):
         if backend.alias not in setting_backends:
             pytest.skip('Setting not available for backend {}'.format(backend))
 
-        vcs_settings_url = route_path(
-            'edit_repo_vcs', repo_name=backend.repo.repo_name)
+        vcs_settings_url = route_path('edit_repo_vcs', repo_name=backend.repo.repo_name)
 
-        with mock.patch.dict(
-                rhodecode.CONFIG, {'labs_settings_active': 'true'}):
+        with mock.patch.dict(rhodecode.CONFIG, {'labs_settings_active': 'true'}):
             response = self.app.get(vcs_settings_url)
 
         assertr = response.assert_response()

rhodecode/apps/ssh_support/lib/backends/base.py

@@ -20,7 +20,7 b' import os'
 import sys
 import logging
 
-from rhodecode.lib.hook_daemon.base import prepare_callback_daemon
+from rhodecode.lib.hook_daemon.utils import prepare_callback_daemon
 from rhodecode.lib.ext_json import sjson as json
 from rhodecode.lib.vcs.conf import settings as vcs_settings
 from rhodecode.lib.api_utils import call_service_api
@@ -162,9 +162,7 b' class SshVcsServer(object):'
         extras = {}
         extras.update(tunnel_extras)
 
-        callback_daemon, extras = prepare_callback_daemon(
-            extras, protocol=self.hooks_protocol,
-            host=vcs_settings.HOOKS_HOST)
+        callback_daemon, extras = prepare_callback_daemon(extras, protocol=self.hooks_protocol)
 
         with callback_daemon:
             try:

rhodecode/apps/ssh_support/tests/test_server_git.py

@@ -33,19 +33,24 b' class GitServerCreator(object):'
         'app:main': {
             'ssh.executable.git': git_path,
             'vcs.hooks.protocol.v2': 'celery',
+            'app.service_api.host': 'http://localhost',
+            'app.service_api.token': 'secret4',
+            'rhodecode.api.url': '/_admin/api',
         }
     }
     repo_name = 'test_git'
     repo_mode = 'receive-pack'
     user = plain_dummy_user()
 
-    def __init__(self):
-        pass
+    def __init__(self, service_api_url, ini_file):
+        self.service_api_url = service_api_url
+        self.ini_file = ini_file
 
     def create(self, **kwargs):
+        self.config_data['app:main']['app.service_api.host'] = self.service_api_url
         parameters = {
             'store': self.root,
-            'ini_path': '',
+            'ini_path': self.ini_file,
             'user': self.user,
             'repo_name': self.repo_name,
             'repo_mode': self.repo_mode,
@@ -60,12 +65,30 b' class GitServerCreator(object):'
         return server
 
 
[e-mail]()
-def git_server(app):
-    return GitServerCreator()
[e-mail](scope='module')
+def git_server(request, module_app, rhodecode_factory, available_port_factory):
+    ini_file = module_app._pyramid_settings['__file__']
+    vcsserver_host = module_app._pyramid_settings['vcs.server']
+
+    store_dir = os.path.dirname(ini_file)
+
+    # start rhodecode for service API
+    rc = rhodecode_factory(
+        request,
+        store_dir=store_dir,
+        port=available_port_factory(),
+        overrides=(
+            {'handler_console': {'level': 'DEBUG'}},
+            {'app:main': {'vcs.server': vcsserver_host}},
+            {'app:main': {'repo_store.path': store_dir}}
+        ))
+
+    service_api_url = f'http://{rc.bind_addr}'
+
+    return GitServerCreator(service_api_url, ini_file)
 
 
-class TestGitServer(object):
+class TestGitServer:
 
     def test_command(self, git_server):
         server = git_server.create()
@@ -102,14 +125,14 b' class TestGitServer(object):'
         assert result is value
 
     def test_run_returns_executes_command(self, git_server):
+        from rhodecode.apps.ssh_support.lib.backends.git import GitTunnelWrapper
         server = git_server.create()
-        from rhodecode.apps.ssh_support.lib.backends.git import GitTunnelWrapper
 
         os.environ['SSH_CLIENT'] = '127.0.0.1'
         with mock.patch.object(GitTunnelWrapper, 'create_hooks_env') as _patch:
             _patch.return_value = 0
             with mock.patch.object(GitTunnelWrapper, 'command', return_value='date'):
-                exit_code = server.run()
+                exit_code = server.run(tunnel_extras={'config': server.ini_path})
 
         assert exit_code == (0, False)
 
@@ -135,7 +158,7 b' class TestGitServer(object):'
             'action': action,
             'ip': '10.10.10.10',
             'locked_by': [None, None],
-            'config': '',
+            'config': git_server.ini_file,
             'repo_store': store,
             'server_url': None,
             'hooks': ['push', 'pull'],

rhodecode/apps/ssh_support/tests/test_server_hg.py

@@ -17,6 +17,7 b''
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
+
 import mock
 import pytest
 
@@ -32,22 +33,27 b' class MercurialServerCreator(object):'
         'app:main': {
             'ssh.executable.hg': hg_path,
             'vcs.hooks.protocol.v2': 'celery',
+            'app.service_api.host': 'http://localhost',
+            'app.service_api.token': 'secret4',
+            'rhodecode.api.url': '/_admin/api',
         }
     }
     repo_name = 'test_hg'
     user = plain_dummy_user()
 
-    def __init__(self):
-        pass
+    def __init__(self, service_api_url, ini_file):
+        self.service_api_url = service_api_url
+        self.ini_file = ini_file
 
     def create(self, **kwargs):
+        self.config_data['app:main']['app.service_api.host'] = self.service_api_url
         parameters = {
             'store': self.root,
-            'ini_path': '',
+            'ini_path': self.ini_file,
             'user': self.user,
             'repo_name': self.repo_name,
             'user_permissions': {
-                'test_hg': 'repository.admin'
+                self.repo_name: 'repository.admin'
             },
             'settings': self.config_data['app:main'],
             'env': plain_dummy_env()
@@ -57,12 +63,30 b' class MercurialServerCreator(object):'
         return server
 
 
[e-mail]()
-def hg_server(app):
-    return MercurialServerCreator()
[e-mail](scope='module')
+def hg_server(request, module_app, rhodecode_factory, available_port_factory):
+    ini_file = module_app._pyramid_settings['__file__']
+    vcsserver_host = module_app._pyramid_settings['vcs.server']
+
+    store_dir = os.path.dirname(ini_file)
+
+    # start rhodecode for service API
+    rc = rhodecode_factory(
+        request,
+        store_dir=store_dir,
+        port=available_port_factory(),
+        overrides=(
+            {'handler_console': {'level': 'DEBUG'}},
+            {'app:main': {'vcs.server': vcsserver_host}},
+            {'app:main': {'repo_store.path': store_dir}}
+        ))
+
+    service_api_url = f'http://{rc.bind_addr}'
+
+    return MercurialServerCreator(service_api_url, ini_file)
 
 
-class TestMercurialServer(object):
+class TestMercurialServer:
 
     def test_command(self, hg_server, tmpdir):
         server = hg_server.create()
@@ -107,7 +131,7 b' class TestMercurialServer(object):'
         with mock.patch.object(MercurialTunnelWrapper, 'create_hooks_env') as _patch:
             _patch.return_value = 0
             with mock.patch.object(MercurialTunnelWrapper, 'command', return_value='date'):
-                exit_code = server.run()
+                exit_code = server.run(tunnel_extras={'config': server.ini_path})
 
         assert exit_code == (0, False)
 

rhodecode/apps/ssh_support/tests/test_server_svn.py

@@ -15,7 +15,9 b''
 # 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
 
@@ -26,39 +28,62 b' from rhodecode.apps.ssh_support.tests.co'
 class SubversionServerCreator(object):
     root = '/tmp/repo/path/'
     svn_path = '/usr/local/bin/svnserve'
+
     config_data = {
         'app:main': {
             'ssh.executable.svn': svn_path,
             'vcs.hooks.protocol.v2': 'celery',
+            'app.service_api.host': 'http://localhost',
+            'app.service_api.token': 'secret4',
+            'rhodecode.api.url': '/_admin/api',
         }
     }
     repo_name = 'test-svn'
     user = plain_dummy_user()
 
-    def __init__(self):
-        pass
+    def __init__(self, service_api_url, ini_file):
+        self.service_api_url = service_api_url
+        self.ini_file = ini_file
 
     def create(self, **kwargs):
+        self.config_data['app:main']['app.service_api.host'] = self.service_api_url
         parameters = {
             'store': self.root,
+            'ini_path': self.ini_file,
+            'user': self.user,
             'repo_name': self.repo_name,
-            'ini_path': '',
-            'user': self.user,
             'user_permissions': {
                 self.repo_name: 'repository.admin'
             },
             'settings': self.config_data['app:main'],
             'env': plain_dummy_env()
         }
-
         parameters.update(kwargs)
         server = SubversionServer(**parameters)
         return server
 
 
[e-mail]()
-def svn_server(app):
-    return SubversionServerCreator()
[e-mail](scope='module')
+def svn_server(request, module_app, rhodecode_factory, available_port_factory):
+    ini_file = module_app._pyramid_settings['__file__']
+    vcsserver_host = module_app._pyramid_settings['vcs.server']
+
+    store_dir = os.path.dirname(ini_file)
+
+    # start rhodecode for service API
+    rc = rhodecode_factory(
+        request,
+        store_dir=store_dir,
+        port=available_port_factory(),
+        overrides=(
+            {'handler_console': {'level': 'DEBUG'}},
+            {'app:main': {'vcs.server': vcsserver_host}},
+            {'app:main': {'repo_store.path': store_dir}}
+        ))
+
+    service_api_url = f'http://{rc.bind_addr}'
+
+    return SubversionServerCreator(service_api_url, ini_file)
 
 
 class TestSubversionServer(object):
@@ -168,8 +193,9 b' class TestSubversionServer(object):'
             assert repo_name == expected_match
 
     def test_run_returns_executes_command(self, svn_server):
+        from rhodecode.apps.ssh_support.lib.backends.svn import SubversionTunnelWrapper
+
         server = svn_server.create()
-        from rhodecode.apps.ssh_support.lib.backends.svn import SubversionTunnelWrapper
         os.environ['SSH_CLIENT'] = '127.0.0.1'
         with mock.patch.object(
                 SubversionTunnelWrapper, 'get_first_client_response',
@@ -184,20 +210,18 b' class TestSubversionServer(object):'
                             SubversionTunnelWrapper, 'command',
                             return_value=['date']):
 
-                        exit_code = server.run()
+                        exit_code = server.run(tunnel_extras={'config': server.ini_path})
         # SVN has this differently configured, and we get in our mock env
         # None as return code
         assert exit_code == (None, False)
 
     def test_run_returns_executes_command_that_cannot_extract_repo_name(self, svn_server):
+        from rhodecode.apps.ssh_support.lib.backends.svn import SubversionTunnelWrapper
+
         server = svn_server.create()
-        from rhodecode.apps.ssh_support.lib.backends.svn import SubversionTunnelWrapper
-        with mock.patch.object(
-                SubversionTunnelWrapper, 'command',
-                return_value=['date']):
-            with mock.patch.object(
-                    SubversionTunnelWrapper, 'get_first_client_response',
+        with mock.patch.object(SubversionTunnelWrapper, 'command', return_value=['date']):
+            with mock.patch.object(SubversionTunnelWrapper, 'get_first_client_response',
                     return_value=None):
-                    exit_code = server.run()
+                    exit_code = server.run(tunnel_extras={'config': server.ini_path})
 
         assert exit_code == (1, False)

rhodecode/apps/user_group/tests/test_user_groups.py

@@ -22,7 +22,7 b' from rhodecode.tests import ('
     TestController, assert_session_flash, TEST_USER_ADMIN_LOGIN)
 from rhodecode.model.db import UserGroup
 from rhodecode.model.meta import Session
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/user_group_profile/tests/test_user_group.py

@@ -18,7 +18,7 b''
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.tests import (
     TestController, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 fixture = Fixture()

rhodecode/apps/user_profile/tests/test_users.py

@@ -22,7 +22,7 b' from rhodecode.model.db import User'
 from rhodecode.tests import (
     TestController, TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS,
     TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.utils import AssertResponse
 from rhodecode.tests.routes import route_path
 

rhodecode/config/environment.py

@@ -30,7 +30,7 b' from rhodecode.lib.vcs import connect_vc'
 log = logging.getLogger(__name__)
 
 
-def propagate_rhodecode_config(global_config, settings, config):
+def propagate_rhodecode_config(global_config, settings, config, full=True):
     # Store the settings to make them available to other modules.
     settings_merged = global_config.copy()
     settings_merged.update(settings)
@@ -40,7 +40,7 b' def propagate_rhodecode_config(global_co'
     rhodecode.PYRAMID_SETTINGS = settings_merged
     rhodecode.CONFIG = settings_merged
 
-    if 'default_user_id' not in rhodecode.CONFIG:
+    if full and 'default_user_id' not in rhodecode.CONFIG:
         rhodecode.CONFIG['default_user_id'] = utils.get_default_user_id()
     log.debug('set rhodecode.CONFIG data')
 
@@ -93,6 +93,7 b' def load_pyramid_environment(global_conf'
     # first run, to store data...
     propagate_rhodecode_config(global_config, settings, {})
 
+
     if vcs_server_enabled:
         connect_vcs(vcs_server_uri, utils.get_vcs_server_protocol(settings))
     else:

rhodecode/config/middleware.py

@@ -101,6 +101,9 b' def make_pyramid_app(global_config, **se'
     patches.inspect_getargspec()
     patches.repoze_sendmail_lf_fix()
 
+    # first init, so load_pyramid_enviroment, can access some critical data, like __file__
+    propagate_rhodecode_config(global_config, {}, {}, full=False)
+
     load_pyramid_environment(global_config, settings)
 
     # Static file view comes first

rhodecode/config/rcextensions/__init__.py

@@ -17,7 +17,7 b''
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
-rcextensions module, please edit `hooks.py` to over write hooks logic
+rcextensions module, please edit `hooks.py` to over-write hooks logic
 """
 
 from .hooks import (

rhodecode/config/rcextensions/examples/validate_pushed_files_name_and_size.py

@@ -85,7 +85,7 b' def _pre_push_hook(*args, **kwargs):'
 
         # check files names
         if forbidden_files:
-            reason = 'File {} is forbidden to be pushed'.format(file_name)
+            reason = f'File {file_name} is forbidden to be pushed'
             for forbidden_pattern in forbid_files:
                 # here we can also filter for operation, e.g if check for only ADDED files
                 # if operation == 'A':

rhodecode/config/rcextensions/helpers/extra_fields.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2016-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -55,7 +54,7 b' def run(*args, **kwargs):'
     return fields
 
 
-class _Undefined(object):
+class _Undefined:
     pass
 
 
@@ -67,7 +66,7 b' def get_field(extra_fields_data, key, de'
 
     if key not in extra_fields_data:
         if isinstance(default, _Undefined):
-            raise ValueError('key {} not present in extra_fields'.format(key))
+            raise ValueError(f'key {key} not present in extra_fields')
         return default
 
     # NOTE(dan): from metadata we get field_label, field_value, field_desc, field_type

rhodecode/config/rcextensions/helpers/extract_post_commits.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2016-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify

rhodecode/config/rcextensions/helpers/extract_pre_commits.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2016-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -52,7 +51,7 b' def get_git_commits(repo, refs):'
         cmd = [
             'log',
             '--pretty=format:{"commit_id": "%H",  "author": "%aN <%aE>",  "date": "%ad",  "message": "%s"}',
-            '{}...{}'.format(old_rev, new_rev)
+            f'{old_rev}...{new_rev}'
         ]
 
         stdout, stderr = repo.run_git_command(cmd, extra_env=git_env)
@@ -80,12 +79,12 b' def run(*args, **kwargs):'
 
     if vcs_type == 'git':
         for rev_data in kwargs['commit_ids']:
-            new_environ = dict((k, v) for k, v in rev_data['git_env'])
+            new_environ = {k: v for k, v in rev_data['git_env']}
         commits = get_git_commits(vcs_repo, kwargs['commit_ids'])
 
     if vcs_type == 'hg':
         for rev_data in kwargs['commit_ids']:
-            new_environ = dict((k, v) for k, v in rev_data['hg_env'])
+            new_environ = {k: v for k, v in rev_data['hg_env']}
         commits = get_hg_commits(vcs_repo, kwargs['commit_ids'])
 
     return commits

rhodecode/config/rcextensions/helpers/extract_pre_files.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2016-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -133,12 +132,12 b' def run(*args, **kwargs):'
 
     if vcs_type == 'git':
         for rev_data in kwargs['commit_ids']:
-            new_environ = dict((k, v) for k, v in rev_data['git_env'])
+            new_environ = {k: v for k, v in rev_data['git_env']}
         files = get_git_files(repo, vcs_repo, kwargs['commit_ids'])
 
     if vcs_type == 'hg':
         for rev_data in kwargs['commit_ids']:
-            new_environ = dict((k, v) for k, v in rev_data['hg_env'])
+            new_environ = {k: v for k, v in rev_data['hg_env']}
         files = get_hg_files(repo, vcs_repo, kwargs['commit_ids'])
 
     if vcs_type == 'svn':

rhodecode/config/rcextensions/helpers/http_call.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2016-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify

rhodecode/config/rcextensions/utils.py

@@ -28,7 +28,7 b' import urllib.error'
 log = logging.getLogger('rhodecode.' + __name__)
 
 
-class HookResponse(object):
+class HookResponse:
     def __init__(self, status, output):
         self.status = status
         self.output = output
@@ -44,6 +44,11 b' class HookResponse(object):'
     def __bool__(self):
         return self.status == 0
 
+    def to_json(self):
+        return {'status': self.status, 'output': self.output}
+
+    def __repr__(self):
+        return self.to_json().__repr__()
 
 class DotDict(dict):
 
@@ -91,8 +96,8 b' class DotDict(dict):'
     def __repr__(self):
         keys = list(self.keys())
         keys.sort()
-        args = ', '.join(['%s=%r' % (key, self[key]) for key in keys])
-        return '%s(%s)' % (self.__class__.__name__, args)
+        args = ', '.join(['{}={!r}'.format(key, self[key]) for key in keys])
+        return '{}({})'.format(self.__class__.__name__, args)
 
     @staticmethod
     def fromDict(d):
@@ -110,7 +115,7 b' def serialize(x):'
 
 def unserialize(x):
     if isinstance(x, dict):
-        return dict((k, unserialize(v)) for k, v in x.items())
+        return {k: unserialize(v) for k, v in x.items()}
     elif isinstance(x, (list, tuple)):
         return type(x)(unserialize(v) for v in x)
     else:
@@ -161,7 +166,8 b' def str2bool(_str) -> bool:'
     string into boolean
 
     :param _str: string value to translate into boolean
-    :returns: bool from given string
+    :rtype: boolean
+    :returns: boolean from given string
     """
     if _str is None:
         return False

rhodecode/config/routing_links.py

@@ -49,22 +49,22 b' link_config = ['
     {
         "name": "enterprise_docs",
         "target": "https://rhodecode.com/r1/enterprise/docs/",
-        "external_target": "https://docs.rhodecode.com/RhodeCode-Enterprise/",
+        "external_target": "https://docs.rhodecode.com/4.x/rce/index.html",
     },
     {
         "name": "enterprise_log_file_locations",
         "target": "https://rhodecode.com/r1/enterprise/docs/admin-system-overview/",
-        "external_target": "https://docs.rhodecode.com/RhodeCode-Enterprise/admin/system-overview.html#log-files",
+        "external_target": "https://docs.rhodecode.com/4.x/rce/admin/system-overview.html#log-files",
     },
     {
         "name": "enterprise_issue_tracker_settings",
         "target": "https://rhodecode.com/r1/enterprise/docs/issue-trackers-overview/",
-        "external_target": "https://docs.rhodecode.com/RhodeCode-Enterprise/issue-trackers/issue-trackers.html",
+        "external_target": "https://docs.rhodecode.com/4.x/rce/issue-trackers/issue-trackers.html",
     },
     {
         "name": "enterprise_svn_setup",
         "target": "https://rhodecode.com/r1/enterprise/docs/svn-setup/",
-        "external_target": "https://docs.rhodecode.com/RhodeCode-Enterprise/admin/svn-http.html",
+        "external_target": "https://docs.rhodecode.com/4.x/rce/admin/svn-http.html",
     },
     {
         "name": "enterprise_license_convert_from_old",

rhodecode/config/utils.py

@@ -19,6 +19,8 b''
 import os
 import platform
 
+from rhodecode.lib.type_utils import str2bool
+
 DEFAULT_USER = 'default'
 
 
@@ -48,28 +50,23 b' def initialize_database(config):'
     engine = engine_from_config(config, 'sqlalchemy.db1.')
     init_model(engine, encryption_key=get_encryption_key(config))
 
+def initialize_test_environment(settings):
+    skip_test_env = str2bool(os.environ.get('RC_NO_TEST_ENV'))
+    if skip_test_env:
+        return
 
-def initialize_test_environment(settings, test_env=None):
-    if test_env is None:
-        test_env = not int(os.environ.get('RC_NO_TMP_PATH', 0))
+    repo_store_path = os.environ.get('RC_TEST_ENV_REPO_STORE') or settings['repo_store.path']
 
     from rhodecode.lib.utils import (
         create_test_directory, create_test_database, create_test_repositories,
         create_test_index)
-    from rhodecode.tests import TESTS_TMP_PATH
-    from rhodecode.lib.vcs.backends.hg import largefiles_store
-    from rhodecode.lib.vcs.backends.git import lfs_store
 
+    create_test_directory(repo_store_path)
+
+    create_test_database(repo_store_path, settings)
     # test repos
-    if test_env:
-        create_test_directory(TESTS_TMP_PATH)
-        # large object stores
-        create_test_directory(largefiles_store(TESTS_TMP_PATH))
-        create_test_directory(lfs_store(TESTS_TMP_PATH))
-
-        create_test_database(TESTS_TMP_PATH, settings)
-        create_test_repositories(TESTS_TMP_PATH, settings)
-        create_test_index(TESTS_TMP_PATH, settings)
+    create_test_repositories(repo_store_path, settings)
+    create_test_index(repo_store_path, settings)
 
 
 def get_vcs_server_protocol(config):

rhodecode/lib/exceptions.py

@@ -20,8 +20,7 b''
 Set of custom exceptions used in RhodeCode
 """
 
-from webob.exc import HTTPClientError
-from pyramid.httpexceptions import HTTPBadGateway
+from pyramid.httpexceptions import HTTPBadGateway, HTTPClientError
 
 
 class LdapUsernameError(Exception):
@@ -102,12 +101,7 b' class HTTPRequirementError(HTTPClientErr'
         self.args = (message, )
 
 
-class ClientNotSupportedError(HTTPRequirementError):
-    title = explanation = 'Client Not Supported'
-    reason = None
-
-
-class HTTPLockedRC(HTTPClientError):
+class HTTPLockedRepo(HTTPClientError):
     """
     Special Exception For locked Repos in RhodeCode, the return code can
     be overwritten by _code keyword argument passed into constructors
@@ -131,14 +125,13 b' class HTTPBranchProtected(HTTPClientErro'
     Special Exception For Indicating that branch is protected in RhodeCode, the
     return code can be overwritten by _code keyword argument passed into constructors
     """
-    code = 403
     title = explanation = 'Branch Protected'
     reason = None
 
-    def __init__(self, message, *args, **kwargs):
-        self.title = self.explanation = message
-        super().__init__(*args, **kwargs)
-        self.args = (message, )
+
+class ClientNotSupported(HTTPRequirementError):
+    title = explanation = 'Client Not Supported'
+    reason = None
 
 
 class IMCCommitError(Exception):

rhodecode/lib/hook_daemon/base.py

@@ -1,4 +1,4 b''
-# Copyright (C) 2010-2023 RhodeCode GmbH
+# Copyright (C) 2010-2024 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
@@ -16,13 +16,14 b''
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
-import os
-import time
 import logging
+import traceback
 
-from rhodecode.lib.config_utils import get_app_config_lightweight
+from rhodecode.model import meta
+from rhodecode.lib import hooks_base
+from rhodecode.lib.utils2 import AttributeDict
+from rhodecode.lib.exceptions import HTTPLockedRepo, HTTPBranchProtected
 
-from rhodecode.lib.svn_txn_utils import get_txn_id_from_store
 
 log = logging.getLogger(__name__)
 
@@ -42,53 +43,82 b' class BaseHooksCallbackDaemon:'
         log.debug('Exiting `%s` callback daemon', self.__class__.__name__)
 
 
-class HooksModuleCallbackDaemon(BaseHooksCallbackDaemon):
+class Hooks(object):
+    """
+    Exposes the hooks module for calling them using the local HooksModuleCallbackDaemon
+    """
+    def __init__(self, request=None, log_prefix=''):
+        self.log_prefix = log_prefix
+        self.request = request
 
-    def __init__(self, module):
-        super().__init__()
-        self.hooks_module = module
+    def repo_size(self, extras):
+        log.debug("%sCalled repo_size of %s object", self.log_prefix, self)
+        return self._call_hook(hooks_base.repo_size, extras)
 
-    def __repr__(self):
-        return f'HooksModuleCallbackDaemon(hooks_module={self.hooks_module})'
-
+    def pre_pull(self, extras):
+        log.debug("%sCalled pre_pull of %s object", self.log_prefix, self)
+        return self._call_hook(hooks_base.pre_pull, extras)
 
-def prepare_callback_daemon(extras, protocol, host, txn_id=None):
+    def post_pull(self, extras):
+        log.debug("%sCalled post_pull of %s object", self.log_prefix, self)
+        return self._call_hook(hooks_base.post_pull, extras)
+
+    def pre_push(self, extras):
+        log.debug("%sCalled pre_push of %s object", self.log_prefix, self)
+        return self._call_hook(hooks_base.pre_push, extras)
 
-    match protocol:
-        case 'http':
-            from rhodecode.lib.hook_daemon.http_hooks_deamon import HttpHooksCallbackDaemon
-            port = 0
-            if txn_id:
-                # read txn-id to re-use the PORT for callback daemon
-                repo_path = os.path.join(extras['repo_store'], extras['repository'])
-                txn_details = get_txn_id_from_store(repo_path, txn_id)
-                port = txn_details.get('port', 0)
+    def post_push(self, extras):
+        log.debug("%sCalled post_push of %s object", self.log_prefix, self)
+        return self._call_hook(hooks_base.post_push, extras)
+
+    def _call_hook(self, hook, extras):
+        extras = AttributeDict(extras)
+        _server_url = extras['server_url']
 
-            callback_daemon = HttpHooksCallbackDaemon(
-                txn_id=txn_id, host=host, port=port)
-        case 'celery':
-            from rhodecode.lib.hook_daemon.celery_hooks_deamon import CeleryHooksCallbackDaemon
-
-            config = get_app_config_lightweight(extras['config'])
-            task_queue = config.get('celery.broker_url')
-            task_backend = config.get('celery.result_backend')
+        extras.request = self.request
+        try:
+            result = hook(extras)
+            if result is None:
+                raise Exception(f'Failed to obtain hook result from func: {hook}')
+        except HTTPBranchProtected as error:
+            # Those special cases don't need error reporting. It's a case of
+            # locked repo or protected branch
+            result = AttributeDict({
+                'status': error.code,
+                'output': error.explanation
+            })
+        except HTTPLockedRepo as error:
+            # Those special cases don't need error reporting. It's a case of
+            # locked repo or protected branch
+            result = AttributeDict({
+                'status': error.code,
+                'output': error.explanation
+            })
+        except Exception as error:
+            # locked needs different handling since we need to also
+            # handle PULL operations
+            log.exception('%sException when handling hook %s', self.log_prefix, hook)
+            exc_tb = traceback.format_exc()
+            error_args = error.args
+            return {
+                'status': 128,
+                'output': '',
+                'exception': type(error).__name__,
+                'exception_traceback': exc_tb,
+                'exception_args': error_args,
+            }
+        finally:
+            meta.Session.remove()
 
-            callback_daemon = CeleryHooksCallbackDaemon(task_queue, task_backend)
-        case 'local':
-            from rhodecode.lib.hook_daemon.hook_module import Hooks
-            callback_daemon = HooksModuleCallbackDaemon(Hooks.__module__)
-        case _:
-            log.error('Unsupported callback daemon protocol "%s"', protocol)
-            raise Exception('Unsupported callback daemon protocol.')
+        log.debug('%sGot hook call response %s', self.log_prefix, result)
+        return {
+            'status': result.status,
+            'output': result.output,
+        }
 
-    extras['hooks_uri'] = getattr(callback_daemon, 'hooks_uri', '')
-    extras['task_queue'] = getattr(callback_daemon, 'task_queue', '')
-    extras['task_backend'] = getattr(callback_daemon, 'task_backend', '')
-    extras['hooks_protocol'] = protocol
-    extras['time'] = time.time()
+    def __enter__(self):
+        return self
 
-    # register txn_id
-    extras['txn_id'] = txn_id
-    log.debug('Prepared a callback daemon: %s',
-              callback_daemon.__class__.__name__)
-    return callback_daemon, extras
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+

rhodecode/lib/hook_daemon/celery_hooks_deamon.py

@@ -22,14 +22,16 b' from rhodecode.lib.hook_daemon.base impo'
 class CeleryHooksCallbackDaemon(BaseHooksCallbackDaemon):
     """
     Context manger for achieving a compatibility with celery backend
+    It is calling a call to vcsserver, where it uses HooksCeleryClient to actually call a task from
+
+    f'rhodecode.lib.celerylib.tasks.{method}'
+
     """
 
-    def __init__(self, task_queue, task_backend):
-        self.task_queue = task_queue
-        self.task_backend = task_backend
+    def __init__(self, broker_url, result_backend):
+        super().__init__()
+        self.broker_url = broker_url
+        self.result_backend = result_backend
 
     def __repr__(self):
-        return f'CeleryHooksCallbackDaemon(task_queue={self.task_queue}, task_backend={self.task_backend})'
-
-    def __repr__(self):
-        return f'CeleryHooksCallbackDaemon(task_queue={self.task_queue}, task_backend={self.task_backend})'
+        return f'CeleryHooksCallbackDaemon(broker_url={self.broker_url}, result_backend={self.result_backend})'

rhodecode/lib/hook_daemon/hook_module.py

@@ -17,88 +17,18 b''
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
-import traceback
 
-from rhodecode.model import meta
-
-from rhodecode.lib import hooks_base
-from rhodecode.lib.exceptions import HTTPLockedRC, HTTPBranchProtected
-from rhodecode.lib.utils2 import AttributeDict
+from rhodecode.lib.hook_daemon.base import BaseHooksCallbackDaemon
 
 log = logging.getLogger(__name__)
 
 
-class Hooks(object):
-    """
-    Exposes the hooks for remote callbacks
-    """
-    def __init__(self, request=None, log_prefix=''):
-        self.log_prefix = log_prefix
-        self.request = request
-
-    def repo_size(self, extras):
-        log.debug("%sCalled repo_size of %s object", self.log_prefix, self)
-        return self._call_hook(hooks_base.repo_size, extras)
-
-    def pre_pull(self, extras):
-        log.debug("%sCalled pre_pull of %s object", self.log_prefix, self)
-        return self._call_hook(hooks_base.pre_pull, extras)
-
-    def post_pull(self, extras):
-        log.debug("%sCalled post_pull of %s object", self.log_prefix, self)
-        return self._call_hook(hooks_base.post_pull, extras)
-
-    def pre_push(self, extras):
-        log.debug("%sCalled pre_push of %s object", self.log_prefix, self)
-        return self._call_hook(hooks_base.pre_push, extras)
-
-    def post_push(self, extras):
-        log.debug("%sCalled post_push of %s object", self.log_prefix, self)
-        return self._call_hook(hooks_base.post_push, extras)
-
-    def _call_hook(self, hook, extras):
-        extras = AttributeDict(extras)
-        _server_url = extras['server_url']
-
-        extras.request = self.request
+class HooksModuleCallbackDaemon(BaseHooksCallbackDaemon):
 
-        try:
-            result = hook(extras)
-            if result is None:
-                raise Exception(f'Failed to obtain hook result from func: {hook}')
-        except HTTPBranchProtected as error:
-            # Those special cases don't need error reporting. It's a case of
-            # locked repo or protected branch
-            result = AttributeDict({
-                'status': error.code,
-                'output': error.explanation
-            })
-        except (HTTPLockedRC, Exception) as error:
-            # locked needs different handling since we need to also
-            # handle PULL operations
-            exc_tb = ''
-            if not isinstance(error, HTTPLockedRC):
-                exc_tb = traceback.format_exc()
-                log.exception('%sException when handling hook %s', self.log_prefix, hook)
-            error_args = error.args
-            return {
-                'status': 128,
-                'output': '',
-                'exception': type(error).__name__,
-                'exception_traceback': exc_tb,
-                'exception_args': error_args,
-            }
-        finally:
-            meta.Session.remove()
+    def __init__(self, module):
+        super().__init__()
+        self.hooks_module = module
 
-        log.debug('%sGot hook call response %s', self.log_prefix, result)
-        return {
-            'status': result.status,
-            'output': result.output,
-        }
+    def __repr__(self):
+        return f'HooksModuleCallbackDaemon(hooks_module={self.hooks_module})'
 
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        pass

rhodecode/lib/hooks_base.py

@@ -30,14 +30,14 b' from rhodecode.lib import helpers as h'
 from rhodecode.lib import audit_logger
 from rhodecode.lib.utils2 import safe_str, user_agent_normalizer
 from rhodecode.lib.exceptions import (
-    HTTPLockedRC, HTTPBranchProtected, UserCreationError, ClientNotSupportedError)
+    HTTPLockedRepo, HTTPBranchProtected, UserCreationError, ClientNotSupported)
 from rhodecode.model.db import Repository, User
 from rhodecode.lib.statsd_client import StatsdClient
 
 log = logging.getLogger(__name__)
 
 
-class HookResponse(object):
+class HookResponse:
     def __init__(self, status, output):
         self.status = status
         self.output = output
@@ -56,6 +56,8 b' class HookResponse(object):'
     def to_json(self):
         return {'status': self.status, 'output': self.output}
 
+    def __repr__(self):
+        return self.to_json().__repr__()
 
 def is_shadow_repo(extras):
     """
@@ -73,8 +75,69 b' def check_vcs_client(extras):'
     except ModuleNotFoundError:
         is_vcs_client_whitelisted = lambda *x: True
     backend = extras.get('scm')
-    if not is_vcs_client_whitelisted(extras.get('user_agent'), backend):
-        raise ClientNotSupportedError(f"Your {backend} client is forbidden")
+    user_agent = extras.get('user_agent')
+    if not is_vcs_client_whitelisted(user_agent, backend):
+        raise ClientNotSupported(f"Your {backend} client (version={user_agent}) is forbidden by security rules")
+
+
+def check_locked_repo(extras, check_same_user=True):
+    user = User.get_by_username(extras.username)
+    output = ''
+    if extras.locked_by[0] and (not check_same_user or user.user_id != extras.locked_by[0]):
+
+        locked_by = User.get(extras.locked_by[0]).username
+        reason = extras.locked_by[2]
+        # this exception is interpreted in git/hg middlewares and based
+        # on that proper return code is server to client
+        _http_ret = HTTPLockedRepo(_locked_by_explanation(extras.repository, locked_by, reason))
+        if str(_http_ret.code).startswith('2'):
+            # 2xx Codes don't raise exceptions
+            output = _http_ret.title
+        else:
+            raise _http_ret
+
+    return output
+
+
+def check_branch_protected(extras):
+    if extras.commit_ids and extras.check_branch_perms:
+        user = User.get_by_username(extras.username)
+        auth_user = user.AuthUser()
+        repo = Repository.get_by_repo_name(extras.repository)
+        if not repo:
+            raise ValueError(f'Repo for {extras.repository} not found')
+        affected_branches = []
+        if repo.repo_type == 'hg':
+            for entry in extras.commit_ids:
+                if entry['type'] == 'branch':
+                    is_forced = bool(entry['multiple_heads'])
+                    affected_branches.append([entry['name'], is_forced])
+        elif repo.repo_type == 'git':
+            for entry in extras.commit_ids:
+                if entry['type'] == 'heads':
+                    is_forced = bool(entry['pruned_sha'])
+                    affected_branches.append([entry['name'], is_forced])
+
+        for branch_name, is_forced in affected_branches:
+
+            rule, branch_perm = auth_user.get_rule_and_branch_permission(extras.repository, branch_name)
+            if not branch_perm:
+                # no branch permission found for this branch, just keep checking
+                continue
+
+            if branch_perm == 'branch.push_force':
+                continue
+            elif branch_perm == 'branch.push' and is_forced is False:
+                continue
+            elif branch_perm == 'branch.push' and is_forced is True:
+                halt_message = f'Branch `{branch_name}` changes rejected by rule {rule}. ' \
+                               f'FORCE PUSH FORBIDDEN.'
+            else:
+                halt_message = f'Branch `{branch_name}` changes rejected by rule {rule}.'
+
+            if halt_message:
+                _http_ret = HTTPBranchProtected(halt_message)
+                raise _http_ret
 
 def _get_scm_size(alias, root_path):
 
@@ -109,116 +172,30 b' def repo_size(extras):'
     repo = Repository.get_by_repo_name(extras.repository)
     vcs_part = f'.{repo.repo_type}'
     size_vcs, size_root, size_total = _get_scm_size(vcs_part, repo.repo_full_path)
-    msg = (f'RhodeCode: `{repo.repo_name}` size summary {vcs_part}:{size_vcs} repo:{size_root} total:{size_total}\n')
+    msg = f'RhodeCode: `{repo.repo_name}` size summary {vcs_part}:{size_vcs} repo:{size_root} total:{size_total}\n'
     return HookResponse(0, msg)
 
 
-def pre_push(extras):
-    """
-    Hook executed before pushing code.
-
-    It bans pushing when the repository is locked.
-    """
-
-    check_vcs_client(extras)
-    user = User.get_by_username(extras.username)
-    output = ''
-    if extras.locked_by[0] and user.user_id != int(extras.locked_by[0]):
-        locked_by = User.get(extras.locked_by[0]).username
-        reason = extras.locked_by[2]
-        # this exception is interpreted in git/hg middlewares and based
-        # on that proper return code is server to client
-        _http_ret = HTTPLockedRC(
-            _locked_by_explanation(extras.repository, locked_by, reason))
-        if str(_http_ret.code).startswith('2'):
-            # 2xx Codes don't raise exceptions
-            output = _http_ret.title
-        else:
-            raise _http_ret
-
-    hook_response = ''
-    if not is_shadow_repo(extras):
-
-        if extras.commit_ids and extras.check_branch_perms:
-            auth_user = user.AuthUser()
-            repo = Repository.get_by_repo_name(extras.repository)
-            if not repo:
-                raise ValueError(f'Repo for {extras.repository} not found')
-            affected_branches = []
-            if repo.repo_type == 'hg':
-                for entry in extras.commit_ids:
-                    if entry['type'] == 'branch':
-                        is_forced = bool(entry['multiple_heads'])
-                        affected_branches.append([entry['name'], is_forced])
-            elif repo.repo_type == 'git':
-                for entry in extras.commit_ids:
-                    if entry['type'] == 'heads':
-                        is_forced = bool(entry['pruned_sha'])
-                        affected_branches.append([entry['name'], is_forced])
-
-            for branch_name, is_forced in affected_branches:
-
-                rule, branch_perm = auth_user.get_rule_and_branch_permission(
-                    extras.repository, branch_name)
-                if not branch_perm:
-                    # no branch permission found for this branch, just keep checking
-                    continue
-
-                if branch_perm == 'branch.push_force':
-                    continue
-                elif branch_perm == 'branch.push' and is_forced is False:
-                    continue
-                elif branch_perm == 'branch.push' and is_forced is True:
-                    halt_message = f'Branch `{branch_name}` changes rejected by rule {rule}. ' \
-                                   f'FORCE PUSH FORBIDDEN.'
-                else:
-                    halt_message = f'Branch `{branch_name}` changes rejected by rule {rule}.'
-
-                if halt_message:
-                    _http_ret = HTTPBranchProtected(halt_message)
-                    raise _http_ret
-
-        # Propagate to external components. This is done after checking the
-        # lock, for consistent behavior.
-        hook_response = pre_push_extension(
-            repo_store_path=Repository.base_path(), **extras)
-        events.trigger(events.RepoPrePushEvent(
-            repo_name=extras.repository, extras=extras))
-
-    return HookResponse(0, output) + hook_response
-
-
 def pre_pull(extras):
     """
     Hook executed before pulling the code.
 
     It bans pulling when the repository is locked.
+    It bans pulling when incorrect client is used.
     """
-
-    check_vcs_client(extras)
     output = ''
-    if extras.locked_by[0]:
-        locked_by = User.get(extras.locked_by[0]).username
-        reason = extras.locked_by[2]
-        # this exception is interpreted in git/hg middlewares and based
-        # on that proper return code is server to client
-        _http_ret = HTTPLockedRC(
-            _locked_by_explanation(extras.repository, locked_by, reason))
-        if str(_http_ret.code).startswith('2'):
-            # 2xx Codes don't raise exceptions
-            output = _http_ret.title
-        else:
-            raise _http_ret
+    check_vcs_client(extras)
+
+    # locking repo can, but not have to stop the operation it can also just produce output
+    output += check_locked_repo(extras, check_same_user=False)
 
     # Propagate to external components. This is done after checking the
     # lock, for consistent behavior.
     hook_response = ''
     if not is_shadow_repo(extras):
         extras.hook_type = extras.hook_type or 'pre_pull'
-        hook_response = pre_pull_extension(
-            repo_store_path=Repository.base_path(), **extras)
-        events.trigger(events.RepoPrePullEvent(
-            repo_name=extras.repository, extras=extras))
+        hook_response = pre_pull_extension(repo_store_path=Repository.base_path(), **extras)
+        events.trigger(events.RepoPrePullEvent(repo_name=extras.repository, extras=extras))
 
     return HookResponse(0, output) + hook_response
 
@@ -239,6 +216,7 b' def post_pull(extras):'
         statsd.incr('rhodecode_pull_total', tags=[
             f'user-agent:{user_agent_normalizer(extras.user_agent)}',
         ])
+
     output = ''
     # make lock is a tri state False, True, None. We only make lock on True
     if extras.make_lock is True and not is_shadow_repo(extras):
@@ -246,18 +224,9 b' def post_pull(extras):'
         Repository.lock(Repository.get_by_repo_name(extras.repository),
                         user.user_id,
                         lock_reason=Repository.LOCK_PULL)
-        msg = 'Made lock on repo `{}`'.format(extras.repository)
+        msg = f'Made lock on repo `{extras.repository}`'
         output += msg
 
-    if extras.locked_by[0]:
-        locked_by = User.get(extras.locked_by[0]).username
-        reason = extras.locked_by[2]
-        _http_ret = HTTPLockedRC(
-            _locked_by_explanation(extras.repository, locked_by, reason))
-        if str(_http_ret.code).startswith('2'):
-            # 2xx Codes don't raise exceptions
-            output += _http_ret.title
-
     # Propagate to external components.
     hook_response = ''
     if not is_shadow_repo(extras):
@@ -270,6 +239,33 b' def post_pull(extras):'
     return HookResponse(0, output) + hook_response
 
 
+def pre_push(extras):
+    """
+    Hook executed before pushing code.
+
+    It bans pushing when the repository is locked.
+    It banks pushing when incorrect client is used.
+    It also checks for Branch protection
+    """
+    output = ''
+    check_vcs_client(extras)
+
+    # locking repo can, but not have to stop the operation it can also just produce output
+    output += check_locked_repo(extras)
+
+    hook_response = ''
+    if not is_shadow_repo(extras):
+
+        check_branch_protected(extras)
+
+        # Propagate to external components. This is done after checking the
+        # lock, for consistent behavior.
+        hook_response = pre_push_extension(repo_store_path=Repository.base_path(), **extras)
+        events.trigger(events.RepoPrePushEvent(repo_name=extras.repository, extras=extras))
+
+    return HookResponse(0, output) + hook_response
+
+
 def post_push(extras):
     """Hook executed after user pushes to the repository."""
     commit_ids = extras.commit_ids
@@ -292,22 +288,13 b' def post_push(extras):'
 
     # Propagate to external components.
     output = ''
+
     # make lock is a tri state False, True, None. We only release lock on False
     if extras.make_lock is False and not is_shadow_repo(extras):
         Repository.unlock(Repository.get_by_repo_name(extras.repository))
         msg = f'Released lock on repo `{extras.repository}`\n'
         output += msg
 
-    if extras.locked_by[0]:
-        locked_by = User.get(extras.locked_by[0]).username
-        reason = extras.locked_by[2]
-        _http_ret = HTTPLockedRC(
-            _locked_by_explanation(extras.repository, locked_by, reason))
-        # TODO: johbo: if not?
-        if str(_http_ret.code).startswith('2'):
-            # 2xx Codes don't raise exceptions
-            output += _http_ret.title
-
     if extras.new_refs:
         tmpl = '{}/{}/pull-request/new?{{ref_type}}={{ref_name}}'.format(
             safe_str(extras.server_url), safe_str(extras.repository))
@@ -322,11 +309,8 b' def post_push(extras):'
 
     hook_response = ''
     if not is_shadow_repo(extras):
-        hook_response = post_push_extension(
-            repo_store_path=Repository.base_path(),
-            **extras)
-        events.trigger(events.RepoPushEvent(
-            repo_name=extras.repository, pushed_commit_ids=commit_ids, extras=extras))
+        hook_response = post_push_extension(repo_store_path=Repository.base_path(), **extras)
+        events.trigger(events.RepoPushEvent(repo_name=extras.repository, pushed_commit_ids=commit_ids, extras=extras))
 
     output += 'RhodeCode: push completed\n'
     return HookResponse(0, output) + hook_response
@@ -380,12 +364,20 b' class ExtensionCallback(object):'
         # with older rcextensions that require api_key present
         if self._hook_name in ['CREATE_USER_HOOK', 'DELETE_USER_HOOK']:
             kwargs_to_pass['api_key'] = '_DEPRECATED_'
-        return callback(**kwargs_to_pass)
+        result = callback(**kwargs_to_pass)
+        log.debug('got rcextensions result: %s', result)
+        return result
 
     def is_active(self):
         return hasattr(rhodecode.EXTENSIONS, self._hook_name)
 
     def _get_callback(self):
+        if rhodecode.is_test:
+            log.debug('In test mode, reloading rcextensions...')
+            # NOTE: for test re-load rcextensions always so we can dynamically change them for testing purposes
+            from rhodecode.lib.utils import load_rcextensions
+            load_rcextensions(root_path=os.path.dirname(rhodecode.CONFIG['__file__']))
+            return getattr(rhodecode.EXTENSIONS, self._hook_name, None)
         return getattr(rhodecode.EXTENSIONS, self._hook_name, None)
 
 

rhodecode/lib/middleware/simplegit.py

@@ -40,16 +40,6 b' GIT_PROTO_PAT = re.compile('
 GIT_LFS_PROTO_PAT = re.compile(r'^/(.+)/(info/lfs/(.+))')
 
 
-def default_lfs_store():
-    """
-    Default lfs store location, it's consistent with Mercurials large file
-    store which is in .cache/largefiles
-    """
-    from rhodecode.lib.vcs.backends.git import lfs_store
-    user_home = os.path.expanduser("~")
-    return lfs_store(user_home)
-
-
 class SimpleGit(simplevcs.SimpleVCS):
 
     SCM = 'git'
@@ -151,6 +141,6 b' class SimpleGit(simplevcs.SimpleVCS):'
 
         extras['git_lfs_enabled'] = utils2.str2bool(
             config.get('vcs_git_lfs', 'enabled'))
-        extras['git_lfs_store_path'] = custom_store or default_lfs_store()
+        extras['git_lfs_store_path'] = custom_store
         extras['git_lfs_http_scheme'] = scheme
         return extras

rhodecode/lib/middleware/simplevcs.py

@@ -1,5 +1,3 b''
-
-
 # Copyright (C) 2014-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -32,8 +30,7 b' from functools import wraps'
 import time
 from paste.httpheaders import REMOTE_USER, AUTH_TYPE
 
-from pyramid.httpexceptions import (
-    HTTPNotFound, HTTPForbidden, HTTPNotAcceptable, HTTPInternalServerError)
+from pyramid.httpexceptions import HTTPNotFound, HTTPForbidden, HTTPNotAcceptable, HTTPInternalServerError
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 import rhodecode
@@ -41,10 +38,9 b' from rhodecode.authentication.base impor'
 from rhodecode.lib import rc_cache
 from rhodecode.lib.svn_txn_utils import store_txn_id_data
 from rhodecode.lib.auth import AuthUser, HasPermissionAnyMiddleware
-from rhodecode.lib.base import (
-    BasicAuth, get_ip_addr, get_user_agent, vcs_operation_context)
-from rhodecode.lib.exceptions import (UserCreationError, NotAllowedToCreateUserError)
-from rhodecode.lib.hook_daemon.base import prepare_callback_daemon
+from rhodecode.lib.base import BasicAuth, get_ip_addr, get_user_agent, vcs_operation_context
+from rhodecode.lib.exceptions import UserCreationError, NotAllowedToCreateUserError
+from rhodecode.lib.hook_daemon.utils import prepare_callback_daemon
 from rhodecode.lib.middleware import appenlight
 from rhodecode.lib.middleware.utils import scm_app_http
 from rhodecode.lib.str_utils import safe_bytes, safe_int
@@ -78,17 +74,18 b' def initialize_generator(factory):'
         try:
             init = next(gen)
         except StopIteration:
-            raise ValueError('Generator must yield at least one element.')
+            raise ValueError("Generator must yield at least one element.")
         if init != "__init__":
             raise ValueError('First yielded element must be "__init__".')
         return gen
+
     return wrapper
 
 
 class SimpleVCS(object):
     """Common functionality for SCM HTTP handlers."""
 
-    SCM = 'unknown'
+    SCM = "unknown"
 
     acl_repo_name = None
     url_repo_name = None
@@ -100,11 +97,11 b' class SimpleVCS(object):'
     # we use this regex which will match only on URLs pointing to shadow
     # repositories.
     shadow_repo_re = re.compile(
-        '(?P<groups>(?:{slug_pat}/)*)'   # repo groups
-        '(?P<target>{slug_pat})/'        # target repo
-        'pull-request/(?P<pr_id>\\d+)/'  # pull request
-        'repository$'                    # shadow repo
-        .format(slug_pat=SLUG_RE.pattern))
+        "(?P<groups>(?:{slug_pat}/)*)"  # repo groups
+        "(?P<target>{slug_pat})/"  # target repo
+        "pull-request/(?P<pr_id>\\d+)/"  # pull request
+        "repository$".format(slug_pat=SLUG_RE.pattern)  # shadow repo
+    )
 
     def __init__(self, config, registry):
         self.registry = registry
@@ -113,15 +110,14 b' class SimpleVCS(object):'
         self.repo_vcs_config = base.Config()
 
         rc_settings = SettingsModel().get_all_settings(cache=True, from_request=False)
-        realm = rc_settings.get('rhodecode_realm') or 'RhodeCode AUTH'
+        realm = rc_settings.get("rhodecode_realm") or "RhodeCode AUTH"
 
         # authenticate this VCS request using authfunc
-        auth_ret_code_detection = \
-            str2bool(self.config.get('auth_ret_code_detection', False))
+        auth_ret_code_detection = str2bool(self.config.get("auth_ret_code_detection", False))
         self.authenticate = BasicAuth(
-            '', authenticate, registry, config.get('auth_ret_code'),
-            auth_ret_code_detection, rc_realm=realm)
-        self.ip_addr = '0.0.0.0'
+            "", authenticate, registry, config.get("auth_ret_code"), auth_ret_code_detection, rc_realm=realm
+        )
+        self.ip_addr = "0.0.0.0"
 
     @LazyProperty
     def global_vcs_config(self):
@@ -132,10 +128,10 b' class SimpleVCS(object):'
 
     @property
     def base_path(self):
-        settings_path = self.config.get('repo_store.path')
+        settings_path = self.config.get("repo_store.path")
 
         if not settings_path:
-            raise ValueError('FATAL: repo_store.path is empty')
+            raise ValueError("FATAL: repo_store.path is empty")
         return settings_path
 
     def set_repo_names(self, environ):
@@ -164,17 +160,16 b' class SimpleVCS(object):'
             match_dict = match.groupdict()
 
             # Build acl repo name from regex match.
-            acl_repo_name = safe_str('{groups}{target}'.format(
-                groups=match_dict['groups'] or '',
-                target=match_dict['target']))
+            acl_repo_name = safe_str(
+                "{groups}{target}".format(groups=match_dict["groups"] or "", target=match_dict["target"])
+            )
 
             # Retrieve pull request instance by ID from regex match.
-            pull_request = PullRequest.get(match_dict['pr_id'])
+            pull_request = PullRequest.get(match_dict["pr_id"])
 
             # Only proceed if we got a pull request and if acl repo name from
             # URL equals the target repo name of the pull request.
             if pull_request and (acl_repo_name == pull_request.target_repo.repo_name):
-
                 # Get file system path to shadow repository.
                 workspace_id = PullRequestModel()._workspace_id(pull_request)
                 vcs_repo_name = pull_request.target_repo.get_shadow_repository_path(workspace_id)
@@ -184,21 +179,23 b' class SimpleVCS(object):'
                 self.acl_repo_name = acl_repo_name
                 self.is_shadow_repo = True
 
-        log.debug('Setting all VCS repository names: %s', {
-            'acl_repo_name': self.acl_repo_name,
-            'url_repo_name': self.url_repo_name,
-            'vcs_repo_name': self.vcs_repo_name,
-        })
+        log.debug(
+            "Setting all VCS repository names: %s",
+            {
+                "acl_repo_name": self.acl_repo_name,
+                "url_repo_name": self.url_repo_name,
+                "vcs_repo_name": self.vcs_repo_name,
+            },
+        )
 
     @property
     def scm_app(self):
-        custom_implementation = self.config['vcs.scm_app_implementation']
-        if custom_implementation == 'http':
-            log.debug('Using HTTP implementation of scm app.')
+        custom_implementation = self.config["vcs.scm_app_implementation"]
+        if custom_implementation == "http":
+            log.debug("Using HTTP implementation of scm app.")
             scm_app_impl = scm_app_http
         else:
-            log.debug('Using custom implementation of scm_app: "{}"'.format(
-                custom_implementation))
+            log.debug('Using custom implementation of scm_app: "{}"'.format(custom_implementation))
             scm_app_impl = importlib.import_module(custom_implementation)
         return scm_app_impl
 
@@ -208,17 +205,18 b' class SimpleVCS(object):'
         with a repository_name for support of _<ID> non changeable urls
         """
 
-        data = repo_name.split('/')
+        data = repo_name.split("/")
         if len(data) >= 2:
             from rhodecode.model.repo import RepoModel
+
             by_id_match = RepoModel().get_repo_by_id(repo_name)
             if by_id_match:
                 data[1] = by_id_match.repo_name
 
         # Because PEP-3333-WSGI uses bytes-tunneled-in-latin-1 as PATH_INFO
         # and we use this data
-        maybe_new_path = '/'.join(data)
-        return safe_bytes(maybe_new_path).decode('latin1')
+        maybe_new_path = "/".join(data)
+        return safe_bytes(maybe_new_path).decode("latin1")
 
     def _invalidate_cache(self, repo_name):
         """
@@ -231,21 +229,18 b' class SimpleVCS(object):'
     def is_valid_and_existing_repo(self, repo_name, base_path, scm_type):
         db_repo = Repository.get_by_repo_name(repo_name)
         if not db_repo:
-            log.debug('Repository `%s` not found inside the database.',
-                      repo_name)
+            log.debug("Repository `%s` not found inside the database.", repo_name)
             return False
 
         if db_repo.repo_type != scm_type:
             log.warning(
-                'Repository `%s` have incorrect scm_type, expected %s got %s',
-                repo_name, db_repo.repo_type, scm_type)
+                "Repository `%s` have incorrect scm_type, expected %s got %s", repo_name, db_repo.repo_type, scm_type
+            )
             return False
 
         config = db_repo._config
-        config.set('extensions', 'largefiles', '')
-        return is_valid_repo(
-            repo_name, base_path,
-            explicit_scm=scm_type, expect_scm=scm_type, config=config)
+        config.set("extensions", "largefiles", "")
+        return is_valid_repo(repo_name, base_path, explicit_scm=scm_type, expect_scm=scm_type, config=config)
 
     def valid_and_active_user(self, user):
         """
@@ -267,8 +262,9 b' class SimpleVCS(object):'
     def is_shadow_repo_dir(self):
         return os.path.isdir(self.vcs_repo_name)
 
-    def _check_permission(self, action, user, auth_user, repo_name, ip_addr=None,
-                          plugin_id='', plugin_cache_active=False, cache_ttl=0):
+    def _check_permission(
+        self, action, user, auth_user, repo_name, ip_addr=None, plugin_id="", plugin_cache_active=False, cache_ttl=0
+    ):
         """
         Checks permissions using action (push/pull) user and repository
         name. If plugin_cache and ttl is set it will use the plugin which
@@ -280,71 +276,67 b' class SimpleVCS(object):'
         :param repo_name: repository name
         """
 
-        log.debug('AUTH_CACHE_TTL for permissions `%s` active: %s (TTL: %s)',
-                  plugin_id, plugin_cache_active, cache_ttl)
+        log.debug("AUTH_CACHE_TTL for permissions `%s` active: %s (TTL: %s)", plugin_id, plugin_cache_active, cache_ttl)
 
         user_id = user.user_id
-        cache_namespace_uid = f'cache_user_auth.{rc_cache.PERMISSIONS_CACHE_VER}.{user_id}'
-        region = rc_cache.get_or_create_region('cache_perms', cache_namespace_uid)
+        cache_namespace_uid = f"cache_user_auth.{rc_cache.PERMISSIONS_CACHE_VER}.{user_id}"
+        region = rc_cache.get_or_create_region("cache_perms", cache_namespace_uid)
 
-        @region.conditional_cache_on_arguments(namespace=cache_namespace_uid,
-                                               expiration_time=cache_ttl,
-                                               condition=plugin_cache_active)
-        def compute_perm_vcs(
-                cache_name, plugin_id, action, user_id, repo_name, ip_addr):
-
-            log.debug('auth: calculating permission access now for vcs operation: %s', action)
+        @region.conditional_cache_on_arguments(
+            namespace=cache_namespace_uid, expiration_time=cache_ttl, condition=plugin_cache_active
+        )
+        def compute_perm_vcs(cache_name, plugin_id, action, user_id, repo_name, ip_addr):
+            log.debug("auth: calculating permission access now for vcs operation: %s", action)
             # check IP
             inherit = user.inherit_default_permissions
-            ip_allowed = AuthUser.check_ip_allowed(
-                user_id, ip_addr, inherit_from_default=inherit)
+            ip_allowed = AuthUser.check_ip_allowed(user_id, ip_addr, inherit_from_default=inherit)
             if ip_allowed:
-                log.info('Access for IP:%s allowed', ip_addr)
+                log.info("Access for IP:%s allowed", ip_addr)
             else:
                 return False
 
-            if action == 'push':
-                perms = ('repository.write', 'repository.admin')
+            if action == "push":
+                perms = ("repository.write", "repository.admin")
                 if not HasPermissionAnyMiddleware(*perms)(auth_user, repo_name):
                     return False
 
             else:
                 # any other action need at least read permission
-                perms = (
-                    'repository.read', 'repository.write', 'repository.admin')
+                perms = ("repository.read", "repository.write", "repository.admin")
                 if not HasPermissionAnyMiddleware(*perms)(auth_user, repo_name):
                     return False
 
             return True
 
         start = time.time()
-        log.debug('Running plugin `%s` permissions check', plugin_id)
+        log.debug("Running plugin `%s` permissions check", plugin_id)
 
         # for environ based auth, password can be empty, but then the validation is
         # on the server that fills in the env data needed for authentication
-        perm_result = compute_perm_vcs(
-            'vcs_permissions', plugin_id, action, user.user_id, repo_name, ip_addr)
+        perm_result = compute_perm_vcs("vcs_permissions", plugin_id, action, user.user_id, repo_name, ip_addr)
 
         auth_time = time.time() - start
-        log.debug('Permissions for plugin `%s` completed in %.4fs, '
-                  'expiration time of fetched cache %.1fs.',
-                  plugin_id, auth_time, cache_ttl)
+        log.debug(
+            "Permissions for plugin `%s` completed in %.4fs, " "expiration time of fetched cache %.1fs.",
+            plugin_id,
+            auth_time,
+            cache_ttl,
+        )
 
         return perm_result
 
     def _get_http_scheme(self, environ):
         try:
-            return environ['wsgi.url_scheme']
+            return environ["wsgi.url_scheme"]
         except Exception:
-            log.exception('Failed to read http scheme')
-            return 'http'
+            log.exception("Failed to read http scheme")
+            return "http"
 
     def _get_default_cache_ttl(self):
         # take AUTH_CACHE_TTL from the `rhodecode` auth plugin
-        plugin = loadplugin('egg:rhodecode-enterprise-ce#rhodecode')
+        plugin = loadplugin("egg:rhodecode-enterprise-ce#rhodecode")
         plugin_settings = plugin.get_settings()
-        plugin_cache_active, cache_ttl = plugin.get_ttl_cache(
-            plugin_settings) or (False, 0)
+        plugin_cache_active, cache_ttl = plugin.get_ttl_cache(plugin_settings) or (False, 0)
         return plugin_cache_active, cache_ttl
 
     def __call__(self, environ, start_response):
@@ -359,17 +351,17 b' class SimpleVCS(object):'
 
     def _handle_request(self, environ, start_response):
         if not self.url_repo_name:
-            log.warning('Repository name is empty: %s', self.url_repo_name)
+            log.warning("Repository name is empty: %s", self.url_repo_name)
             # failed to get repo name, we fail now
             return HTTPNotFound()(environ, start_response)
-        log.debug('Extracted repo name is %s', self.url_repo_name)
+        log.debug("Extracted repo name is %s", self.url_repo_name)
 
         ip_addr = get_ip_addr(environ)
         user_agent = get_user_agent(environ)
         username = None
 
         # skip passing error to error controller
-        environ['pylons.status_code_redirect'] = True
+        environ["pylons.status_code_redirect"] = True
 
         # ======================================================================
         # GET ACTION PULL or PUSH
@@ -380,17 +372,15 b' class SimpleVCS(object):'
         # Check if this is a request to a shadow repository of a pull request.
         # In this case only pull action is allowed.
         # ======================================================================
-        if self.is_shadow_repo and action != 'pull':
-            reason = 'Only pull action is allowed for shadow repositories.'
-            log.debug('User not allowed to proceed, %s', reason)
+        if self.is_shadow_repo and action != "pull":
+            reason = "Only pull action is allowed for shadow repositories."
+            log.debug("User not allowed to proceed, %s", reason)
             return HTTPNotAcceptable(reason)(environ, start_response)
 
         # Check if the shadow repo actually exists, in case someone refers
         # to it, and it has been deleted because of successful merge.
         if self.is_shadow_repo and not self.is_shadow_repo_dir:
-            log.debug(
-                'Shadow repo detected, and shadow repo dir `%s` is missing',
-                self.is_shadow_repo_dir)
+            log.debug("Shadow repo detected, and shadow repo dir `%s` is missing", self.is_shadow_repo_dir)
             return HTTPNotFound()(environ, start_response)
 
         # ======================================================================
@@ -398,7 +388,7 b' class SimpleVCS(object):'
         # ======================================================================
         detect_force_push = False
         check_branch_perms = False
-        if action in ['pull', 'push']:
+        if action in ["pull", "push"]:
             user_obj = anonymous_user = User.get_default_user()
             auth_user = user_obj.AuthUser()
             username = anonymous_user.username
@@ -406,8 +396,12 b' class SimpleVCS(object):'
                 plugin_cache_active, cache_ttl = self._get_default_cache_ttl()
                 # ONLY check permissions if the user is activated
                 anonymous_perm = self._check_permission(
-                    action, anonymous_user, auth_user, self.acl_repo_name, ip_addr,
-                    plugin_id='anonymous_access',
+                    action,
+                    anonymous_user,
+                    auth_user,
+                    self.acl_repo_name,
+                    ip_addr,
+                    plugin_id="anonymous_access",
                     plugin_cache_active=plugin_cache_active,
                     cache_ttl=cache_ttl,
                 )
@@ -416,12 +410,13 b' class SimpleVCS(object):'
 
             if not anonymous_user.active or not anonymous_perm:
                 if not anonymous_user.active:
-                    log.debug('Anonymous access is disabled, running '
-                              'authentication')
+                    log.debug("Anonymous access is disabled, running " "authentication")
 
                 if not anonymous_perm:
-                    log.debug('Not enough credentials to access repo: `%s` '
-                              'repository as anonymous user', self.acl_repo_name)
+                    log.debug(
+                        "Not enough credentials to access repo: `%s` " "repository as anonymous user",
+                        self.acl_repo_name,
+                    )
 
                 username = None
                 # ==============================================================
@@ -430,19 +425,18 b' class SimpleVCS(object):'
                 # ==============================================================
 
                 # try to auth based on environ, container auth methods
-                log.debug('Running PRE-AUTH for container|headers based authentication')
+                log.debug("Running PRE-AUTH for container|headers based authentication")
 
                 # headers auth, by just reading special headers and bypass the auth with user/passwd
                 pre_auth = authenticate(
-                    '', '', environ, VCS_TYPE, registry=self.registry,
-                    acl_repo_name=self.acl_repo_name)
+                    "", "", environ, VCS_TYPE, registry=self.registry, acl_repo_name=self.acl_repo_name
+                )
 
-                if pre_auth and pre_auth.get('username'):
-                    username = pre_auth['username']
-                log.debug('PRE-AUTH got `%s` as username', username)
+                if pre_auth and pre_auth.get("username"):
+                    username = pre_auth["username"]
+                log.debug("PRE-AUTH got `%s` as username", username)
                 if pre_auth:
-                    log.debug('PRE-AUTH successful from %s',
-                              pre_auth.get('auth_data', {}).get('_plugin'))
+                    log.debug("PRE-AUTH successful from %s", pre_auth.get("auth_data", {}).get("_plugin"))
 
                 # If not authenticated by the container, running basic auth
                 # before inject the calling repo_name for special scope checks
@@ -463,16 +457,16 b' class SimpleVCS(object):'
                         return HTTPNotAcceptable(reason)(environ, start_response)
 
                     if isinstance(auth_result, dict):
-                        AUTH_TYPE.update(environ, 'basic')
-                        REMOTE_USER.update(environ, auth_result['username'])
-                        username = auth_result['username']
-                        plugin = auth_result.get('auth_data', {}).get('_plugin')
-                        log.info(
-                            'MAIN-AUTH successful for user `%s` from %s plugin',
-                            username, plugin)
+                        AUTH_TYPE.update(environ, "basic")
+                        REMOTE_USER.update(environ, auth_result["username"])
+                        username = auth_result["username"]
+                        plugin = auth_result.get("auth_data", {}).get("_plugin")
+                        log.info("MAIN-AUTH successful for user `%s` from %s plugin", username, plugin)
 
-                        plugin_cache_active, cache_ttl = auth_result.get(
-                            'auth_data', {}).get('_ttl_cache') or (False, 0)
+                        plugin_cache_active, cache_ttl = auth_result.get("auth_data", {}).get("_ttl_cache") or (
+                            False,
+                            0,
+                        )
                     else:
                         return auth_result.wsgi_application(environ, start_response)
 
@@ -488,21 +482,24 b' class SimpleVCS(object):'
                 # check user attributes for password change flag
                 user_obj = user
                 auth_user = user_obj.AuthUser()
-                if user_obj and user_obj.username != User.DEFAULT_USER and \
-                        user_obj.user_data.get('force_password_change'):
-                    reason = 'password change required'
-                    log.debug('User not allowed to authenticate, %s', reason)
+                if (
+                    user_obj
+                    and user_obj.username != User.DEFAULT_USER
+                    and user_obj.user_data.get("force_password_change")
+                ):
+                    reason = "password change required"
+                    log.debug("User not allowed to authenticate, %s", reason)
                     return HTTPNotAcceptable(reason)(environ, start_response)
 
                 # check permissions for this repository
                 perm = self._check_permission(
-                    action, user, auth_user, self.acl_repo_name, ip_addr,
-                    plugin, plugin_cache_active, cache_ttl)
+                    action, user, auth_user, self.acl_repo_name, ip_addr, plugin, plugin_cache_active, cache_ttl
+                )
                 if not perm:
                     return HTTPForbidden()(environ, start_response)
-                environ['rc_auth_user_id'] = str(user_id)
+                environ["rc_auth_user_id"] = str(user_id)
 
-            if action == 'push':
+            if action == "push":
                 perms = auth_user.get_branch_permissions(self.acl_repo_name)
                 if perms:
                     check_branch_perms = True
@@ -510,41 +507,48 b' class SimpleVCS(object):'
 
         # extras are injected into UI object and later available
         # in hooks executed by RhodeCode
-        check_locking = _should_check_locking(environ.get('QUERY_STRING'))
+        check_locking = _should_check_locking(environ.get("QUERY_STRING"))
 
         extras = vcs_operation_context(
-            environ, repo_name=self.acl_repo_name, username=username,
-            action=action, scm=self.SCM, check_locking=check_locking,
-            is_shadow_repo=self.is_shadow_repo, check_branch_perms=check_branch_perms,
-            detect_force_push=detect_force_push
+            environ,
+            repo_name=self.acl_repo_name,
+            username=username,
+            action=action,
+            scm=self.SCM,
+            check_locking=check_locking,
+            is_shadow_repo=self.is_shadow_repo,
+            check_branch_perms=check_branch_perms,
+            detect_force_push=detect_force_push,
         )
 
         # ======================================================================
         # REQUEST HANDLING
         # ======================================================================
-        repo_path = os.path.join(
-            safe_str(self.base_path), safe_str(self.vcs_repo_name))
-        log.debug('Repository path is %s', repo_path)
+        repo_path = os.path.join(safe_str(self.base_path), safe_str(self.vcs_repo_name))
+        log.debug("Repository path is %s", repo_path)
 
         fix_PATH()
 
         log.info(
             '%s action on %s repo "%s" by "%s" from %s %s',
-            action, self.SCM, safe_str(self.url_repo_name),
-            safe_str(username), ip_addr, user_agent)
+            action,
+            self.SCM,
+            safe_str(self.url_repo_name),
+            safe_str(username),
+            ip_addr,
+            user_agent,
+        )
 
-        return self._generate_vcs_response(
-            environ, start_response, repo_path, extras, action)
+        return self._generate_vcs_response(environ, start_response, repo_path, extras, action)
 
     def _get_txn_id(self, environ):
-
-        for k in ['RAW_URI', 'HTTP_DESTINATION']:
+        for k in ["RAW_URI", "HTTP_DESTINATION"]:
             url = environ.get(k)
             if not url:
                 continue
 
             # regex to search for svn-txn-id
-            pattern = r'/!svn/txr/([^/]+)/'
+            pattern = r"/!svn/txr/([^/]+)/"
 
             # Search for the pattern in the URL
             match = re.search(pattern, url)
@@ -555,8 +559,7 b' class SimpleVCS(object):'
                 return txn_id
 
     @initialize_generator
-    def _generate_vcs_response(
-            self, environ, start_response, repo_path, extras, action):
+    def _generate_vcs_response(self, environ, start_response, repo_path, extras, action):
         """
         Returns a generator for the response content.
 
@@ -565,24 +568,20 b' class SimpleVCS(object):'
         also handles the locking exceptions which will be triggered when
         the first chunk is produced by the underlying WSGI application.
         """
-        svn_txn_id = ''
-        if action == 'push':
+        svn_txn_id = ""
+        if action == "push":
             svn_txn_id = self._get_txn_id(environ)
 
-        callback_daemon, extras = self._prepare_callback_daemon(
-            extras, environ, action, txn_id=svn_txn_id)
+        callback_daemon, extras = self._prepare_callback_daemon(extras, environ, action, txn_id=svn_txn_id)
 
         if svn_txn_id:
-
-            port = safe_int(extras['hooks_uri'].split(':')[-1])
             txn_id_data = extras.copy()
-            txn_id_data.update({'port': port})
-            txn_id_data.update({'req_method': environ['REQUEST_METHOD']})
+            txn_id_data.update({"req_method": environ["REQUEST_METHOD"]})
 
             full_repo_path = repo_path
             store_txn_id_data(full_repo_path, svn_txn_id, txn_id_data)
 
-        log.debug('HOOKS extras is %s', extras)
+        log.debug("HOOKS extras is %s", extras)
 
         http_scheme = self._get_http_scheme(environ)
 
@@ -609,7 +608,7 b' class SimpleVCS(object):'
 
             try:
                 # invalidate cache on push
-                if action == 'push':
+                if action == "push":
                     self._invalidate_cache(self.url_repo_name)
             finally:
                 meta.Session.remove()
@@ -632,12 +631,12 b' class SimpleVCS(object):'
         """Return the WSGI app that will finally handle the request."""
         raise NotImplementedError()
 
-    def _create_config(self, extras, repo_name, scheme='http'):
+    def _create_config(self, extras, repo_name, scheme="http"):
         """Create a safe config representation."""
         raise NotImplementedError()
 
     def _should_use_callback_daemon(self, extras, environ, action):
-        if extras.get('is_shadow_repo'):
+        if extras.get("is_shadow_repo"):
             # we don't want to execute hooks, and callback daemon for shadow repos
             return False
         return True
@@ -647,11 +646,9 b' class SimpleVCS(object):'
 
         if not self._should_use_callback_daemon(extras, environ, action):
             # disable callback daemon for actions that don't require it
-            protocol = 'local'
+            protocol = "local"
 
-        return prepare_callback_daemon(
-            extras, protocol=protocol,
-            host=vcs_settings.HOOKS_HOST, txn_id=txn_id)
+        return prepare_callback_daemon(extras, protocol=protocol, txn_id=txn_id)
 
 
 def _should_check_locking(query_string):
@@ -659,4 +656,4 b' def _should_check_locking(query_string):'
     # server see all operation on commit; bookmarks, phases and
     # obsolescence marker in different transaction, we don't want to check
     # locking on those
-    return query_string not in ['cmd=listkeys']
+    return query_string not in ["cmd=listkeys"]

rhodecode/lib/utils.py

@@ -21,6 +21,7 b' Utilities library for RhodeCode'
 """
 
 import datetime
+import importlib
 
 import decorator
 import logging
@@ -42,8 +43,9 b' from webhelpers2.text import collapse, s'
 
 from mako import exceptions
 
+import rhodecode
 from rhodecode import ConfigGet
-from rhodecode.lib.exceptions import HTTPBranchProtected, HTTPLockedRC
+from rhodecode.lib.exceptions import HTTPBranchProtected, HTTPLockedRepo, ClientNotSupported
 from rhodecode.lib.hash_utils import sha256_safe, md5, sha1
 from rhodecode.lib.type_utils import AttributeDict
 from rhodecode.lib.str_utils import safe_bytes, safe_str
@@ -86,6 +88,7 b' def adopt_for_celery(func):'
     @wraps(func)
     def wrapper(extras):
         extras = AttributeDict(extras)
+
         try:
             # HooksResponse implements to_json method which must be used there.
             return func(extras).to_json()
@@ -100,7 +103,18 b' def adopt_for_celery(func):'
                 'exception_args': error_args,
                 'exception_traceback': '',
             }
-        except HTTPLockedRC as error:
+        except ClientNotSupported as error:
+            # Those special cases don't need error reporting. It's a case of
+            # locked repo or protected branch
+            error_args = error.args
+            return {
+                'status': error.code,
+                'output': error.explanation,
+                'exception': type(error).__name__,
+                'exception_args': error_args,
+                'exception_traceback': '',
+            }
+        except HTTPLockedRepo as error:
             # Those special cases don't need error reporting. It's a case of
             # locked repo or protected branch
             error_args = error.args
@@ -117,7 +131,7 b' def adopt_for_celery(func):'
                 'output': '',
                 'exception': type(e).__name__,
                 'exception_args': e.args,
-                'exception_traceback': '',
+                'exception_traceback': traceback.format_exc(),
             }
     return wrapper
 
@@ -411,6 +425,10 b' def prepare_config_data(clear_session=Tr'
         ('web', 'push_ssl', 'false'),
     ]
     for setting in ui_settings:
+        # skip certain deprecated keys that might be still in DB
+        if f"{setting.section}_{setting.key}" in ['extensions_hgsubversion']:
+            continue
+
         # Todo: remove this section once transition to *.ini files will be completed
         if setting.section in ('largefiles', 'vcs_git_lfs'):
             if setting.key != 'enabled':
@@ -686,22 +704,41 b' def repo2db_mapper(initial_repo_list, re'
 
     return added, removed
 
+def deep_reload_package(package_name):
+    """
+    Deeply reload a package by removing it and its submodules from sys.modules,
+    then re-importing it.
+    """
+    # Remove the package and its submodules from sys.modules
+    to_reload = [name for name in sys.modules if name == package_name or name.startswith(package_name + ".")]
+    for module_name in to_reload:
+        del sys.modules[module_name]
+        log.debug(f"Removed module from cache: {module_name}")
+
+    # Re-import the package
+    package = importlib.import_module(package_name)
+    log.debug(f"Re-imported package: {package_name}")
+
+    return package
 
 def load_rcextensions(root_path):
     import rhodecode
     from rhodecode.config import conf
 
     path = os.path.join(root_path)
-    sys.path.append(path)
+    deep_reload = path in sys.path
+    sys.path.insert(0, path)
 
     try:
-        rcextensions = __import__('rcextensions')
+        rcextensions = __import__('rcextensions', fromlist=[''])
     except ImportError:
         if os.path.isdir(os.path.join(path, 'rcextensions')):
             log.warning('Unable to load rcextensions from %s', path)
         rcextensions = None
 
     if rcextensions:
+        if deep_reload:
+            rcextensions = deep_reload_package('rcextensions')
         log.info('Loaded rcextensions from %s...', rcextensions)
         rhodecode.EXTENSIONS = rcextensions
 
@@ -741,6 +778,7 b' def create_test_index(repo_location, con'
     except ImportError:
         raise ImportError('Failed to import rc_testdata, '
                           'please make sure this package is installed from requirements_test.txt')
+
     rc_testdata.extract_search_index(
         'vcs_search_index', os.path.dirname(config['search.location']))
 
@@ -785,22 +823,15 b' def create_test_repositories(test_path, '
     Creates test repositories in the temporary directory. Repositories are
     extracted from archives within the rc_testdata package.
     """
-    import rc_testdata
+    try:
+        import rc_testdata
+    except ImportError:
+        raise ImportError('Failed to import rc_testdata, '
+                          'please make sure this package is installed from requirements_test.txt')
+
     from rhodecode.tests import HG_REPO, GIT_REPO, SVN_REPO
 
-    log.debug('making test vcs repositories')
-
-    idx_path = config['search.location']
-    data_path = config['cache_dir']
-
-    # clean index and data
-    if idx_path and os.path.exists(idx_path):
-        log.debug('remove %s', idx_path)
-        shutil.rmtree(idx_path)
-
-    if data_path and os.path.exists(data_path):
-        log.debug('remove %s', data_path)
-        shutil.rmtree(data_path)
+    log.debug('making test vcs repositories at %s', test_path)
 
     rc_testdata.extract_hg_dump('vcs_test_hg', jn(test_path, HG_REPO))
     rc_testdata.extract_git_dump('vcs_test_git', jn(test_path, GIT_REPO))

rhodecode/lib/vcs/__init__.py

@@ -140,7 +140,7 b' class CurlSession(object):'
         try:
             curl.perform()
         except pycurl.error as exc:
-            log.error('Failed to call endpoint url: {} using pycurl'.format(url))
+            log.error('Failed to call endpoint url: %s using pycurl', url)
             raise
 
         status_code = curl.getinfo(pycurl.HTTP_CODE)

rhodecode/lib/vcs/backends/git/__init__.py

@@ -45,10 +45,3 b' def discover_git_version(raise_on_exc=Fa'
         if raise_on_exc:
             raise
         return ''
-
-
-def lfs_store(base_location):
-    """
-    Return a lfs store relative to base_location
-    """
-    return os.path.join(base_location, '.cache', 'lfs_store')

rhodecode/lib/vcs/backends/hg/__init__.py

@@ -45,10 +45,3 b' def discover_hg_version(raise_on_exc=Fal'
         if raise_on_exc:
             raise
         return ''
-
-
-def largefiles_store(base_location):
-    """
-    Return a largefile store relative to base_location
-    """
-    return os.path.join(base_location, '.cache', 'largefiles')

rhodecode/lib/vcs/client_http.py

@@ -216,7 +216,7 b' class RemoteRepo(object):'
         self._cache_region, self._cache_namespace = \
             remote_maker.init_cache_region(cache_repo_id)
 
-        with_wire = with_wire or {}
+        with_wire = with_wire or {"cache": False}
 
         repo_state_uid = with_wire.get('repo_state_uid') or 'state'
 

rhodecode/model/comment.py

@@ -373,6 +373,7 b' class CommentsModel(BaseModel):'
 
         Session().add(comment)
         Session().flush()
+
         kwargs = {
             'user': user,
             'renderer_type': renderer,
@@ -387,8 +388,7 b' class CommentsModel(BaseModel):'
         }
 
         if commit_obj:
-            recipients = ChangesetComment.get_users(
-                revision=commit_obj.raw_id)
+            recipients = ChangesetComment.get_users(revision=commit_obj.raw_id)
             # add commit author if it's in RhodeCode system
             cs_author = User.get_from_cs_author(commit_obj.author)
             if not cs_author:
@@ -397,16 +397,13 b' class CommentsModel(BaseModel):'
             recipients += [cs_author]
 
             commit_comment_url = self.get_url(comment, request=request)
-            commit_comment_reply_url = self.get_url(
-                comment, request=request,
-                anchor=f'comment-{comment.comment_id}/?/ReplyToComment')
+            commit_comment_reply_url = self.get_url(comment, request=request, anchor=f'comment-{comment.comment_id}/?/ReplyToComment')
 
             target_repo_url = h.link_to(
                 repo.repo_name,
                 h.route_url('repo_summary', repo_name=repo.repo_name))
 
-            commit_url = h.route_url('repo_commit', repo_name=repo.repo_name,
-                                     commit_id=commit_id)
+            commit_url = h.route_url('repo_commit', repo_name=repo.repo_name, commit_id=commit_id)
 
             # commit specifics
             kwargs.update({
@@ -489,7 +486,6 b' class CommentsModel(BaseModel):'
 
         if not is_draft:
             comment_data = comment.get_api_data()
-
             self._log_audit_action(
                 action, {'data': comment_data}, auth_user, comment)
 

rhodecode/model/pull_request.py

@@ -38,7 +38,7 b' from rhodecode.translation import lazy_u'
 from rhodecode.lib import helpers as h, hooks_utils, diffs
 from rhodecode.lib import audit_logger
 from collections import OrderedDict
-from rhodecode.lib.hook_daemon.base import prepare_callback_daemon
+from rhodecode.lib.hook_daemon.utils import prepare_callback_daemon
 from rhodecode.lib.ext_json import sjson as json
 from rhodecode.lib.markup_renderer import (
     DEFAULT_COMMENTS_RENDERER, RstTemplateRenderer)
@@ -980,9 +980,7 b' class PullRequestModel(BaseModel):'
         target_ref = self._refresh_reference(
             pull_request.target_ref_parts, target_vcs)
 
-        callback_daemon, extras = prepare_callback_daemon(
-            extras, protocol=vcs_settings.HOOKS_PROTOCOL,
-            host=vcs_settings.HOOKS_HOST)
+        callback_daemon, extras = prepare_callback_daemon(extras, protocol=vcs_settings.HOOKS_PROTOCOL)
 
         with callback_daemon:
             # TODO: johbo: Implement a clean way to run a config_override

rhodecode/model/settings.py

@@ -862,27 +862,3 b' class VcsSettingsModel(object):'
                 raise ValueError(
                     f'The given data does not contain {data_key} key')
         return data_keys
-
-    def create_largeobjects_dirs_if_needed(self, repo_store_path):
-        """
-        This is subscribed to the `pyramid.events.ApplicationCreated` event. It
-        does a repository scan if enabled in the settings.
-        """
-
-        from rhodecode.lib.vcs.backends.hg import largefiles_store
-        from rhodecode.lib.vcs.backends.git import lfs_store
-
-        paths = [
-            largefiles_store(repo_store_path),
-            lfs_store(repo_store_path)]
-
-        for path in paths:
-            if os.path.isdir(path):
-                continue
-            if os.path.isfile(path):
-                continue
-            # not a file nor dir, we try to create it
-            try:
-                os.makedirs(path)
-            except Exception:
-                log.warning('Failed to create largefiles dir:%s', path)

rhodecode/tests/__init__.py

@@ -1,5 +1,4 b''
-
-# Copyright (C) 2010-2023 RhodeCode GmbH
+# Copyright (C) 2010-2024 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
@@ -38,7 +37,7 b' from rhodecode.lib.hash_utils import sha'
 log = logging.getLogger(__name__)
 
 __all__ = [
-    'get_new_dir', 'TestController',
+    'get_new_dir', 'TestController', 'console_printer',
     'clear_cache_regions',
     'assert_session_flash', 'login_user', 'no_newline_id_generator',
     'TESTS_TMP_PATH', 'HG_REPO', 'GIT_REPO', 'SVN_REPO',
@@ -244,3 +243,11 b' def no_newline_id_generator(test_name):'
 
     return test_name or 'test-with-empty-name'
 
+def console_printer(*msg):
+    print_func = print
+    try:
+        from rich import print as print_func
+    except ImportError:
+        pass
+
+    print_func(*msg)

rhodecode/tests/auth_external_test.py

@@ -1,5 +1,4 b''
-
-# Copyright (C) 2010-2023 RhodeCode GmbH
+# Copyright (C) 2010-2024 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
@@ -90,7 +89,7 b' class RhodeCodeAuthPlugin(RhodeCodeExter'
                 'firstname': firstname,
                 'lastname': lastname,
                 'groups': [],
-                'email': '[e-mail]' % username,
+                'email': f'{username}@rhodecode.com',
                 'admin': admin,
                 'active': active,
                 "active_from_extern": None,

rhodecode/tests/config/test_routing_links.py

@@ -20,14 +20,14 b''
 import pytest
 import requests
 from rhodecode.config import routing_links
-
+from rhodecode.tests import console_printer
 
 def check_connection():
     try:
         response = requests.get('https://rhodecode.com')
         return response.status_code == 200
     except Exception as e:
-        print(e)
+        console_printer(e)
 
     return False
 

rhodecode/tests/conftest.py

@@ -1,4 +1,4 b''
-# Copyright (C) 2010-2023 RhodeCode GmbH
+# Copyright (C) 2010-2024 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
@@ -16,23 +16,10 b''
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
-"""
-py.test config for test suite for making push/pull operations.
-
-.. important::
-
-   You must have git >= 1.8.5 for tests to work fine. With 68b939b git started
-   to redirect things to stderr instead of stdout.
-"""
-
-import pytest
+import pytest # noqa
 import logging
-
-from rhodecode.authentication import AuthenticationPluginRegistry
-from rhodecode.model.db import Permission, User
-from rhodecode.model.meta import Session
-from rhodecode.model.settings import SettingsModel
-from rhodecode.model.user import UserModel
+import collections
+import rhodecode
 
 
 log = logging.getLogger(__name__)
@@ -40,99 +27,3 b' log = logging.getLogger(__name__)'
 # Docker image running httpbin...
 HTTPBIN_DOMAIN = 'http://httpbin'
 HTTPBIN_POST = HTTPBIN_DOMAIN + '/post'
-
-
[e-mail]()
-def enable_auth_plugins(request, baseapp, csrf_token):
-    """
-    Return a factory object that when called, allows to control which
-    authentication plugins are enabled.
-    """
-
-    class AuthPluginManager(object):
-
-        def cleanup(self):
-            self._enable_plugins(['egg:rhodecode-enterprise-ce#rhodecode'])
-
-        def enable(self, plugins_list, override=None):
-            return self._enable_plugins(plugins_list, override)
-
-        def _enable_plugins(self, plugins_list, override=None):
-            override = override or {}
-            params = {
-                'auth_plugins': ','.join(plugins_list),
-            }
-
-            # helper translate some names to others, to fix settings code
-            name_map = {
-                'token': 'authtoken'
-            }
-            log.debug('enable_auth_plugins: enabling following auth-plugins: %s', plugins_list)
-
-            for module in plugins_list:
-                plugin_name = module.partition('#')[-1]
-                if plugin_name in name_map:
-                    plugin_name = name_map[plugin_name]
-                enabled_plugin = f'auth_{plugin_name}_enabled'
-                cache_ttl = f'auth_{plugin_name}_cache_ttl'
-
-                # default params that are needed for each plugin,
-                # `enabled` and `cache_ttl`
-                params.update({
-                    enabled_plugin: True,
-                    cache_ttl: 0
-                })
-                if override.get:
-                    params.update(override.get(module, {}))
-
-                validated_params = params
-
-                for k, v in validated_params.items():
-                    setting = SettingsModel().create_or_update_setting(k, v)
-                    Session().add(setting)
-                Session().commit()
-
-            AuthenticationPluginRegistry.invalidate_auth_plugins_cache(hard=True)
-
-            enabled_plugins = SettingsModel().get_auth_plugins()
-            assert plugins_list == enabled_plugins
-
-    enabler = AuthPluginManager()
-    request.addfinalizer(enabler.cleanup)
-
-    return enabler
-
-
[e-mail]()
-def test_user_factory(request, baseapp):
-
-    def user_factory(username='test_user', password='qweqwe', first_name='John', last_name='Testing', **kwargs):
-        usr = UserModel().create_or_update(
-            username=username,
-            password=password,
-            email=f'{username}@rhodecode.org',
-            firstname=first_name, lastname=last_name)
-        Session().commit()
-
-        for k, v in kwargs.items():
-            setattr(usr, k, v)
-            Session().add(usr)
-
-        new_usr = User.get_by_username(username)
-        new_usr_id = new_usr.user_id
-        assert new_usr == usr
-
-        @request.addfinalizer
-        def cleanup():
-            if User.get(new_usr_id) is None:
-                return
-
-            perm = Permission.query().all()
-            for p in perm:
-                UserModel().revoke_perm(usr, p)
-
-            UserModel().delete(new_usr_id)
-            Session().commit()
-        return usr
-
-    return user_factory

rhodecode/tests/conftest_common.py

@@ -1,4 +1,4 b''
-# Copyright (C) 2010-2023 RhodeCode GmbH
+# Copyright (C) 2010-2024 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
@@ -98,16 +98,16 b' def pytest_addoption(parser):'
         'pyramid_config',
         "Set up a Pyramid environment with the specified config file.")
 
+    parser.addini('rhodecode_config', 'rhodecode config ini for tests')
+    parser.addini('celery_config', 'celery config ini for tests')
+    parser.addini('vcsserver_config', 'vcsserver config ini for tests')
+
     vcsgroup = parser.getgroup('vcs')
+
     vcsgroup.addoption(
         '--without-vcsserver', dest='with_vcsserver', action='store_false',
         help="Do not start the VCSServer in a background process.")
-    vcsgroup.addoption(
-        '--with-vcsserver-http', dest='vcsserver_config_http',
-        help="Start the HTTP VCSServer with the specified config file.")
-    vcsgroup.addoption(
-        '--vcsserver-protocol', dest='vcsserver_protocol',
-        help="Start the VCSServer with HTTP protocol support.")
+
     vcsgroup.addoption(
         '--vcsserver-config-override', action='store', type=_parse_json,
         default=None, dest='vcsserver_config_override', help=(
@@ -122,12 +122,6 b' def pytest_addoption(parser):'
             "Allows to set the port of the vcsserver. Useful when testing "
             "against an already running server and random ports cause "
             "trouble."))
-    parser.addini(
-        'vcsserver_config_http',
-        "Start the HTTP VCSServer with the specified config file.")
-    parser.addini(
-        'vcsserver_protocol',
-        "Start the VCSServer with HTTP protocol support.")
 
 
 @pytest.hookimpl(tryfirst=True, hookwrapper=True)

rhodecode/tests/database/conftest.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -17,7 +16,7 b''
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
-from subprocess import Popen, PIPE
+import subprocess
 import os
 import sys
 import tempfile
@@ -26,87 +25,71 b' import pytest'
 from sqlalchemy.engine import url
 
 from rhodecode.lib.str_utils import safe_str, safe_bytes
-from rhodecode.tests.fixture import TestINI
+from rhodecode.tests.fixtures.rc_fixture import TestINI
 
 
 def _get_dbs_from_metafunc(metafunc):
-    dbs_mark = metafunc.definition.get_closest_marker('dbs')
+    dbs_mark = metafunc.definition.get_closest_marker("dbs")
 
     if dbs_mark:
         # Supported backends by this test function, created from pytest.mark.dbs
         backends = dbs_mark.args
     else:
-        backends = metafunc.config.getoption('--dbs')
+        backends = metafunc.config.getoption("--dbs")
     return backends
 
 
 def pytest_generate_tests(metafunc):
     # Support test generation based on --dbs parameter
-    if 'db_backend' in metafunc.fixturenames:
-        requested_backends = set(metafunc.config.getoption('--dbs'))
+    if "db_backend" in metafunc.fixturenames:
+        requested_backends = set(metafunc.config.getoption("--dbs"))
         backends = _get_dbs_from_metafunc(metafunc)
         backends = requested_backends.intersection(backends)
         # TODO: johbo: Disabling a backend did not work out with
         # parametrization, find better way to achieve this.
         if not backends:
             metafunc.function._skip = True
-        metafunc.parametrize('db_backend_name', backends)
+        metafunc.parametrize("db_backend_name", backends)
 
 
 def pytest_collection_modifyitems(session, config, items):
-    remaining = [
-        i for i in items if not getattr(i.obj, '_skip', False)]
+    remaining = [i for i in items if not getattr(i.obj, "_skip", False)]
     items[:] = remaining
 
 
 @pytest.fixture()
-def db_backend(
-        request, db_backend_name, ini_config, tmpdir_factory):
+def db_backend(request, db_backend_name, ini_config, tmpdir_factory):
     basetemp = tmpdir_factory.getbasetemp().strpath
     klass = _get_backend(db_backend_name)
 
-    option_name = '--{}-connection-string'.format(db_backend_name)
+    option_name = "--{}-connection-string".format(db_backend_name)
     connection_string = request.config.getoption(option_name) or None
 
-    return klass(
-        config_file=ini_config, basetemp=basetemp,
-        connection_string=connection_string)
+    return klass(config_file=ini_config, basetemp=basetemp, connection_string=connection_string)
 
 
 def _get_backend(backend_type):
-    return {
-        'sqlite': SQLiteDBBackend,
-        'postgres': PostgresDBBackend,
-        'mysql': MySQLDBBackend,
-        '': EmptyDBBackend
-    }[backend_type]
+    return {"sqlite": SQLiteDBBackend, "postgres": PostgresDBBackend, "mysql": MySQLDBBackend, "": EmptyDBBackend}[
+        backend_type
+    ]
 
 
 class DBBackend(object):
     _store = os.path.dirname(os.path.abspath(__file__))
     _type = None
-    _base_ini_config = [{'app:main': {'vcs.start_server': 'false',
-                                      'startup.import_repos': 'false'}}]
-    _db_url = [{'app:main': {'sqlalchemy.db1.url': ''}}]
-    _base_db_name = 'rhodecode_test_db_backend'
-    std_env = {'RC_TEST': '0'}
+    _base_ini_config = [{"app:main": {"vcs.start_server": "false", "startup.import_repos": "false"}}]
+    _db_url = [{"app:main": {"sqlalchemy.db1.url": ""}}]
+    _base_db_name = "rhodecode_test_db_backend"
+    std_env = {"RC_TEST": "0"}
 
-    def __init__(
-            self, config_file, db_name=None, basetemp=None,
-            connection_string=None):
-
-        from rhodecode.lib.vcs.backends.hg import largefiles_store
-        from rhodecode.lib.vcs.backends.git import lfs_store
-
+    def __init__(self, config_file, db_name=None, basetemp=None, connection_string=None):
         self.fixture_store = os.path.join(self._store, self._type)
         self.db_name = db_name or self._base_db_name
         self._base_ini_file = config_file
-        self.stderr = ''
-        self.stdout = ''
+        self.stderr = ""
+        self.stdout = ""
         self._basetemp = basetemp or tempfile.gettempdir()
-        self._repos_location = os.path.join(self._basetemp, 'rc_test_repos')
-        self._repos_hg_largefiles_store = largefiles_store(self._basetemp)
-        self._repos_git_lfs_store = lfs_store(self._basetemp)
+        self._repos_location = os.path.join(self._basetemp, "rc_test_repos")
         self.connection_string = connection_string
 
     @property
@@ -118,8 +101,7 b' class DBBackend(object):'
         if not new_connection_string:
             new_connection_string = self.get_default_connection_string()
         else:
-            new_connection_string = new_connection_string.format(
-                db_name=self.db_name)
+            new_connection_string = new_connection_string.format(db_name=self.db_name)
         url_parts = url.make_url(new_connection_string)
         self._connection_string = new_connection_string
         self.user = url_parts.username
@@ -127,73 +109,67 b' class DBBackend(object):'
         self.host = url_parts.host
 
     def get_default_connection_string(self):
-        raise NotImplementedError('default connection_string is required.')
+        raise NotImplementedError("default connection_string is required.")
 
     def execute(self, cmd, env=None, *args):
         """
         Runs command on the system with given ``args``.
         """
 
-        command = cmd + ' ' + ' '.join(args)
-        sys.stdout.write(f'CMD: {command}')
+        command = cmd + " " + " ".join(args)
+        sys.stdout.write(f"CMD: {command}")
 
         # Tell Python to use UTF-8 encoding out stdout
         _env = os.environ.copy()
-        _env['PYTHONIOENCODING'] = 'UTF-8'
+        _env["PYTHONIOENCODING"] = "UTF-8"
         _env.update(self.std_env)
         if env:
             _env.update(env)
 
-        self.p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, env=_env)
+        self.p = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=_env)
         self.stdout, self.stderr = self.p.communicate()
         stdout_str = safe_str(self.stdout)
-        sys.stdout.write(f'COMMAND:{command}\n')
+        sys.stdout.write(f"COMMAND:{command}\n")
         sys.stdout.write(stdout_str)
         return self.stdout, self.stderr
 
     def assert_returncode_success(self):
         from rich import print as pprint
+
         if not self.p.returncode == 0:
             pprint(safe_str(self.stderr))
-            raise AssertionError(f'non 0 retcode:{self.p.returncode}')
+            raise AssertionError(f"non 0 retcode:{self.p.returncode}")
 
     def assert_correct_output(self, stdout, version):
-        assert b'UPGRADE FOR STEP %b COMPLETED' % safe_bytes(version) in stdout
+        assert b"UPGRADE FOR STEP %b COMPLETED" % safe_bytes(version) in stdout
 
     def setup_rhodecode_db(self, ini_params=None, env=None):
         if not ini_params:
             ini_params = self._base_ini_config
 
         ini_params.extend(self._db_url)
-        with TestINI(self._base_ini_file, ini_params,
-                     self._type, destroy=True) as _ini_file:
-
+        with TestINI(self._base_ini_file, ini_params, self._type, destroy=True) as _ini_file:
             if not os.path.isdir(self._repos_location):
                 os.makedirs(self._repos_location)
-            if not os.path.isdir(self._repos_hg_largefiles_store):
-                os.makedirs(self._repos_hg_largefiles_store)
-            if not os.path.isdir(self._repos_git_lfs_store):
-                os.makedirs(self._repos_git_lfs_store)
 
             return self.execute(
                 "rc-setup-app {0} --user=marcink "
                 "--email=[e-mail] --password={1} "
-                "--repos={2} --force-yes".format(
-                    _ini_file, 'qweqwe', self._repos_location), env=env)
+                "--repos={2} --force-yes".format(_ini_file, "qweqwe", self._repos_location),
+                env=env,
+            )
 
     def upgrade_database(self, ini_params=None):
         if not ini_params:
             ini_params = self._base_ini_config
         ini_params.extend(self._db_url)
 
-        test_ini = TestINI(
-            self._base_ini_file, ini_params, self._type, destroy=True)
+        test_ini = TestINI(self._base_ini_file, ini_params, self._type, destroy=True)
         with test_ini as ini_file:
             if not os.path.isdir(self._repos_location):
                 os.makedirs(self._repos_location)
 
-            return self.execute(
-                "rc-upgrade-db {0} --force-yes".format(ini_file))
+            return self.execute("rc-upgrade-db {0} --force-yes".format(ini_file))
 
     def setup_db(self):
         raise NotImplementedError
@@ -206,7 +182,7 b' class DBBackend(object):'
 
 
 class EmptyDBBackend(DBBackend):
-    _type = ''
+    _type = ""
 
     def setup_db(self):
         pass
@@ -222,21 +198,20 b' class EmptyDBBackend(DBBackend):'
 
 
 class SQLiteDBBackend(DBBackend):
-    _type = 'sqlite'
+    _type = "sqlite"
 
     def get_default_connection_string(self):
-        return 'sqlite:///{}/{}.sqlite'.format(self._basetemp, self.db_name)
+        return "sqlite:///{}/{}.sqlite".format(self._basetemp, self.db_name)
 
     def setup_db(self):
         # dump schema for tests
         # cp -v $TEST_DB_NAME
-        self._db_url = [{'app:main': {
-            'sqlalchemy.db1.url': self.connection_string}}]
+        self._db_url = [{"app:main": {"sqlalchemy.db1.url": self.connection_string}}]
 
     def import_dump(self, dumpname):
         dump = os.path.join(self.fixture_store, dumpname)
-        target = os.path.join(self._basetemp, '{0.db_name}.sqlite'.format(self))
-        return self.execute(f'cp -v {dump} {target}')
+        target = os.path.join(self._basetemp, "{0.db_name}.sqlite".format(self))
+        return self.execute(f"cp -v {dump} {target}")
 
     def teardown_db(self):
         target_db = os.path.join(self._basetemp, self.db_name)
@@ -244,39 +219,39 b' class SQLiteDBBackend(DBBackend):'
 
 
 class MySQLDBBackend(DBBackend):
-    _type = 'mysql'
+    _type = "mysql"
 
     def get_default_connection_string(self):
-        return 'mysql://root:qweqwe@127.0.0.1/{}'.format(self.db_name)
+        return "mysql://root:qweqwe@127.0.0.1/{}".format(self.db_name)
 
     def setup_db(self):
         # dump schema for tests
         # mysqldump -uroot -pqweqwe $TEST_DB_NAME
-        self._db_url = [{'app:main': {
-            'sqlalchemy.db1.url': self.connection_string}}]
-        return self.execute("mysql -v -u{} -p{} -e 'create database '{}';'".format(
-            self.user, self.password, self.db_name))
+        self._db_url = [{"app:main": {"sqlalchemy.db1.url": self.connection_string}}]
+        return self.execute(
+            "mysql -v -u{} -p{} -e 'create database '{}';'".format(self.user, self.password, self.db_name)
+        )
 
     def import_dump(self, dumpname):
         dump = os.path.join(self.fixture_store, dumpname)
-        return self.execute("mysql -u{} -p{} {} < {}".format(
-            self.user, self.password, self.db_name, dump))
+        return self.execute("mysql -u{} -p{} {} < {}".format(self.user, self.password, self.db_name, dump))
 
     def teardown_db(self):
-        return self.execute("mysql -v -u{} -p{} -e 'drop database '{}';'".format(
-            self.user, self.password, self.db_name))
+        return self.execute(
+            "mysql -v -u{} -p{} -e 'drop database '{}';'".format(self.user, self.password, self.db_name)
+        )
 
 
 class PostgresDBBackend(DBBackend):
-    _type = 'postgres'
+    _type = "postgres"
 
     def get_default_connection_string(self):
-        return 'postgresql://postgres:qweqwe@localhost/{}'.format(self.db_name)
+        return "postgresql://postgres:qweqwe@localhost/{}".format(self.db_name)
 
     def setup_db(self):
         # dump schema for tests
         # pg_dump -U postgres -h localhost $TEST_DB_NAME
-        self._db_url = [{'app:main': {'sqlalchemy.db1.url': self.connection_string}}]
+        self._db_url = [{"app:main": {"sqlalchemy.db1.url": self.connection_string}}]
         cmd = f"PGPASSWORD={self.password} psql -U {self.user} -h localhost -c 'create database '{self.db_name}';'"
         return self.execute(cmd)
 

rhodecode/tests/database/test_creation.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify

rhodecode/tests/database/test_migration.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -21,33 +20,42 b' import pytest'
 
 
 @pytest.mark.dbs("postgres")
[e-mail]("dumpname", [
-    '1.4.4.sql',
-    '1.5.0.sql',
-    '1.6.0.sql',
-    '1.6.0_no_repo_name_index.sql',
-])
[e-mail](
+    "dumpname",
+    [
+        "1.4.4.sql",
+        "1.5.0.sql",
+        "1.6.0.sql",
+        "1.6.0_no_repo_name_index.sql",
+    ],
+)
 def test_migrate_postgres_db(db_backend, dumpname):
     _run_migration_test(db_backend, dumpname)
 
 
 @pytest.mark.dbs("sqlite")
[e-mail]("dumpname", [
-    'rhodecode.1.4.4.sqlite',
-    'rhodecode.1.4.4_with_groups.sqlite',
-    'rhodecode.1.4.4_with_ldap_active.sqlite',
-])
[e-mail](
+    "dumpname",
+    [
+        "rhodecode.1.4.4.sqlite",
+        "rhodecode.1.4.4_with_groups.sqlite",
+        "rhodecode.1.4.4_with_ldap_active.sqlite",
+    ],
+)
 def test_migrate_sqlite_db(db_backend, dumpname):
     _run_migration_test(db_backend, dumpname)
 
 
 @pytest.mark.dbs("mysql")
[e-mail]("dumpname", [
-    '1.4.4.sql',
-    '1.5.0.sql',
-    '1.6.0.sql',
-    '1.6.0_no_repo_name_index.sql',
-])
[e-mail](
+    "dumpname",
+    [
+        "1.4.4.sql",
+        "1.5.0.sql",
+        "1.6.0.sql",
+        "1.6.0_no_repo_name_index.sql",
+    ],
+)
 def test_migrate_mysql_db(db_backend, dumpname):
     _run_migration_test(db_backend, dumpname)
 
@@ -60,5 +68,5 b' def _run_migration_test(db_backend, dump'
     db_backend.import_dump(dumpname)
     stdout, stderr = db_backend.upgrade_database()
 
-    db_backend.assert_correct_output(stdout+stderr, version='16')
+    db_backend.assert_correct_output(stdout + stderr, version="16")
     db_backend.assert_returncode_success()

rhodecode/tests/fixtures/fixture_pyramid.py

@@ -1,5 +1,4 b''
-
-# Copyright (C) 2010-2023 RhodeCode GmbH
+# Copyright (C) 2010-2024 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
@@ -20,61 +19,128 b''
 import pytest
 
 from rhodecode.lib.config_utils import get_app_config
-from rhodecode.tests.fixture import TestINI
+from rhodecode.tests.fixtures.rc_fixture import TestINI
 from rhodecode.tests import TESTS_TMP_PATH
 from rhodecode.tests.server_utils import RcVCSServer
+from rhodecode.tests.server_utils import RcWebServer
+from rhodecode.tests.server_utils import CeleryServer
 
 
[e-mail](scope='session')
-def vcsserver(request, vcsserver_port, vcsserver_factory):
-    """
-    Session scope VCSServer.
-
-    Tests which need the VCSServer have to rely on this fixture in order
-    to ensure it will be running.
-
-    For specific needs, the fixture vcsserver_factory can be used. It allows to
-    adjust the configuration file for the test run.
-
-    Command line args:
-
-    --without-vcsserver: Allows to switch this fixture off. You have to
-    manually start the server.
-
-    --vcsserver-port: Will expect the VCSServer to listen on this port.
-    """
-
-    if not request.config.getoption('with_vcsserver'):
-        return None
-
-    return vcsserver_factory(
-        request, vcsserver_port=vcsserver_port)
-
-
[e-mail](scope='session')
-def vcsserver_factory(tmpdir_factory):
[e-mail](scope="session")
+def vcsserver_factory():
     """
     Use this if you need a running vcsserver with a special configuration.
     """
 
-    def factory(request, overrides=(), vcsserver_port=None,
-                log_file=None, workers='3'):
-
-        if vcsserver_port is None:
+    def factory(request, store_dir, overrides=(), config_file=None, port=None, log_file=None, workers="3", env=None, info_prefix=""):
+        env = env or {"RC_NO_TEST_ENV": "1"}
+        vcsserver_port = port
+        if port is None:
             vcsserver_port = get_available_port()
 
         overrides = list(overrides)
-        overrides.append({'server:main': {'port': vcsserver_port}})
+        overrides.append({"server:main": {"port": vcsserver_port}})
+
+        if getattr(request, 'param', None):
+            config_overrides = [request.param]
+            overrides.extend(config_overrides)
+
+        option_name = "vcsserver_config"
+        override_option_name = None
+        if not config_file:
+            config_file = get_config(
+                request.config,
+                option_name=option_name,
+                override_option_name=override_option_name,
+                overrides=overrides,
+                basetemp=store_dir,
+                prefix=f"{info_prefix}test_vcsserver_ini_",
+            )
+        server = RcVCSServer(config_file, log_file, workers, env=env, info_prefix=info_prefix)
+        server.start()
+
+        @request.addfinalizer
+        def cleanup():
+            server.shutdown()
+
+        server.wait_until_ready()
+        return server
+
+    return factory
+
+
[e-mail](scope="session")
+def rhodecode_factory():
+    def factory(request, store_dir, overrides=(), config_file=None, port=None, log_file=None, workers="3", env=None, info_prefix=""):
+        env = env or {"RC_NO_TEST_ENV": "1"}
+        rhodecode_port = port
+        if port is None:
+            rhodecode_port = get_available_port()
+
+        overrides = list(overrides)
+        overrides.append({"server:main": {"port": rhodecode_port}})
+        overrides.append({"app:main": {"use_celery": "true"}})
+        overrides.append({"app:main": {"celery.task_always_eager": "false"}})
+
+        if getattr(request, 'param', None):
+            config_overrides = [request.param]
+            overrides.extend(config_overrides)
+
 
-        option_name = 'vcsserver_config_http'
-        override_option_name = 'vcsserver_config_override'
-        config_file = get_config(
-            request.config, option_name=option_name,
-            override_option_name=override_option_name, overrides=overrides,
-            basetemp=tmpdir_factory.getbasetemp().strpath,
-            prefix='test_vcs_')
+        option_name = "rhodecode_config"
+        override_option_name = None
+        if not config_file:
+            config_file = get_config(
+                request.config,
+                option_name=option_name,
+                override_option_name=override_option_name,
+                overrides=overrides,
+                basetemp=store_dir,
+                prefix=f"{info_prefix}test_rhodecode_ini",
+            )
+
+        server = RcWebServer(config_file, log_file, workers, env, info_prefix=info_prefix)
+        server.start()
+
+        @request.addfinalizer
+        def cleanup():
+            server.shutdown()
+
+        server.wait_until_ready()
+        return server
+
+    return factory
+
 
-        server = RcVCSServer(config_file, log_file, workers)
[e-mail](scope="session")
+def celery_factory():
+    def factory(request, store_dir, overrides=(), config_file=None, port=None, log_file=None, workers="3", env=None, info_prefix=""):
+        env = env or {"RC_NO_TEST_ENV": "1"}
+        rhodecode_port = port
+
+        overrides = list(overrides)
+        overrides.append({"app:main": {"use_celery": "true"}})
+        overrides.append({"app:main": {"celery.task_always_eager": "false"}})
+        config_overrides = None
+
+        if getattr(request, 'param', None):
+            config_overrides = [request.param]
+            overrides.extend(config_overrides)
+
+        option_name = "celery_config"
+        override_option_name = None
+
+        if not config_file:
+            config_file = get_config(
+                request.config,
+                option_name=option_name,
+                override_option_name=override_option_name,
+                overrides=overrides,
+                basetemp=store_dir,
+                prefix=f"{info_prefix}test_celery_ini_",
+            )
+
+        server = CeleryServer(config_file, log_file, workers, env, info_prefix=info_prefix)
         server.start()
 
         @request.addfinalizer
@@ -88,52 +154,68 b' def vcsserver_factory(tmpdir_factory):'
 
 
 def _use_log_level(config):
-    level = config.getoption('test_loglevel') or 'critical'
+    level = config.getoption("test_loglevel") or "critical"
     return level.upper()
 
 
[e-mail](scope='session')
-def ini_config(request, tmpdir_factory, rcserver_port, vcsserver_port):
-    option_name = 'pyramid_config'
+def _ini_config_factory(request, base_dir, rcserver_port, vcsserver_port):
+    option_name = "pyramid_config"
     log_level = _use_log_level(request.config)
 
     overrides = [
-        {'server:main': {'port': rcserver_port}},
-        {'app:main': {
-            'cache_dir': '%(here)s/rc-tests/rc_data',
-            'vcs.server': f'localhost:{vcsserver_port}',
-            # johbo: We will always start the VCSServer on our own based on the
-            # fixtures of the test cases. For the test run it must always be
-            # off in the INI file.
-            'vcs.start_server': 'false',
-
-            'vcs.server.protocol': 'http',
-            'vcs.scm_app_implementation': 'http',
-            'vcs.svn.proxy.enabled': 'true',
-            'vcs.hooks.protocol.v2': 'celery',
-            'vcs.hooks.host': '*',
-            'repo_store.path': TESTS_TMP_PATH,
-            'app.service_api.token': 'service_secret_token',
-        }},
-
-        {'handler_console': {
-            'class': 'StreamHandler',
-            'args': '(sys.stderr,)',
-            'level': log_level,
-        }},
-
+        {"server:main": {"port": rcserver_port}},
+        {
+            "app:main": {
+                #'cache_dir': '%(here)s/rc-tests/rc_data',
+                "vcs.server": f"localhost:{vcsserver_port}",
+                # johbo: We will always start the VCSServer on our own based on the
+                # fixtures of the test cases. For the test run it must always be
+                # off in the INI file.
+                "vcs.start_server": "false",
+                "vcs.server.protocol": "http",
+                "vcs.scm_app_implementation": "http",
+                "vcs.svn.proxy.enabled": "true",
+                "vcs.hooks.protocol.v2": "celery",
+                "vcs.hooks.host": "*",
+                "repo_store.path": TESTS_TMP_PATH,
+                "app.service_api.token": "service_secret_token",
+            }
+        },
+        {
+            "handler_console": {
+                "class": "StreamHandler",
+                "args": "(sys.stderr,)",
+                "level": log_level,
+            }
+        },
     ]
 
     filename = get_config(
-        request.config, option_name=option_name,
-        override_option_name='{}_override'.format(option_name),
+        request.config,
+        option_name=option_name,
+        override_option_name=f"{option_name}_override",
         overrides=overrides,
-        basetemp=tmpdir_factory.getbasetemp().strpath,
-        prefix='test_rce_')
+        basetemp=base_dir,
+        prefix="test_rce_",
+    )
     return filename
 
 
[e-mail](scope='session')
[e-mail](scope="session")
+def ini_config(request, tmpdir_factory, rcserver_port, vcsserver_port):
+    base_dir = tmpdir_factory.getbasetemp().strpath
+    return _ini_config_factory(request, base_dir, rcserver_port, vcsserver_port)
+
+
[e-mail](scope="session")
+def ini_config_factory(request, tmpdir_factory, rcserver_port, vcsserver_port):
+    def _factory(ini_config_basedir, overrides=()):
+        return _ini_config_factory(request, ini_config_basedir, rcserver_port, vcsserver_port)
+
+    return _factory
+
+
[e-mail](scope="session")
 def ini_settings(ini_config):
     ini_path = ini_config
     return get_app_config(ini_path)
@@ -141,26 +223,25 b' def ini_settings(ini_config):'
 
 def get_available_port(min_port=40000, max_port=55555):
     from rhodecode.lib.utils2 import get_available_port as _get_port
+
     return _get_port(min_port, max_port)
 
 
[e-mail](scope='session')
[e-mail](scope="session")
 def rcserver_port(request):
     port = get_available_port()
-    print(f'Using rhodecode port {port}')
     return port
 
 
[e-mail](scope='session')
[e-mail](scope="session")
 def vcsserver_port(request):
-    port = request.config.getoption('--vcsserver-port')
+    port = request.config.getoption("--vcsserver-port")
     if port is None:
         port = get_available_port()
-        print(f'Using vcsserver port {port}')
     return port
 
 
[e-mail](scope='session')
[e-mail](scope="session")
 def available_port_factory() -> get_available_port:
     """
     Returns a callable which returns free port numbers.
@@ -178,7 +259,7 b' def available_port(available_port_factor'
     return available_port_factory()
 
 
[e-mail](scope='session')
[e-mail](scope="session")
 def testini_factory(tmpdir_factory, ini_config):
     """
     Factory to create an INI file based on TestINI.
@@ -190,37 +271,38 b' def testini_factory(tmpdir_factory, ini_'
 
 
 class TestIniFactory(object):
-
-    def __init__(self, basetemp, template_ini):
-        self._basetemp = basetemp
+    def __init__(self, ini_store_dir, template_ini):
+        self._ini_store_dir = ini_store_dir
         self._template_ini = template_ini
 
-    def __call__(self, ini_params, new_file_prefix='test'):
+    def __call__(self, ini_params, new_file_prefix="test"):
         ini_file = TestINI(
-            self._template_ini, ini_params=ini_params,
-            new_file_prefix=new_file_prefix, dir=self._basetemp)
+            self._template_ini, ini_params=ini_params, new_file_prefix=new_file_prefix, dir=self._ini_store_dir
+        )
         result = ini_file.create()
         return result
 
 
-def get_config(
-        config, option_name, override_option_name, overrides=None,
-        basetemp=None, prefix='test'):
+def get_config(config, option_name, override_option_name, overrides=None, basetemp=None, prefix="test"):
     """
     Find a configuration file and apply overrides for the given `prefix`.
     """
-    config_file = (
-        config.getoption(option_name) or config.getini(option_name))
+    try:
+        config_file = config.getoption(option_name)
+    except ValueError:
+        config_file = None
+
     if not config_file:
-        pytest.exit(
-            "Configuration error, could not extract {}.".format(option_name))
+        config_file = config.getini(option_name)
+
+    if not config_file:
+        pytest.exit(f"Configuration error, could not extract {option_name}.")
 
     overrides = overrides or []
-    config_override = config.getoption(override_option_name)
-    if config_override:
-        overrides.append(config_override)
-    temp_ini_file = TestINI(
-        config_file, ini_params=overrides, new_file_prefix=prefix,
-        dir=basetemp)
+    if override_option_name:
+        config_override = config.getoption(override_option_name)
+        if config_override:
+            overrides.append(config_override)
+    temp_ini_file = TestINI(config_file, ini_params=overrides, new_file_prefix=prefix, dir=basetemp)
 
     return temp_ini_file.create()

rhodecode/tests/fixtures/fixture_utils.py

@@ -1,5 +1,4 b''
-
-# Copyright (C) 2010-2023 RhodeCode GmbH
+# Copyright (C) 2010-2024 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
@@ -30,6 +29,7 b' import uuid'
 import dateutil.tz
 import logging
 import functools
+import textwrap
 
 import mock
 import pyramid.testing
@@ -43,8 +43,17 b' import rhodecode.lib'
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
-    PullRequest, PullRequestReviewers, Repository, RhodeCodeSetting, ChangesetStatus,
-    RepoGroup, UserGroup, RepoRhodeCodeUi, RepoRhodeCodeSetting, RhodeCodeUi)
+    PullRequest,
+    PullRequestReviewers,
+    Repository,
+    RhodeCodeSetting,
+    ChangesetStatus,
+    RepoGroup,
+    UserGroup,
+    RepoRhodeCodeUi,
+    RepoRhodeCodeSetting,
+    RhodeCodeUi,
+)
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.repo import RepoModel
@@ -60,12 +69,20 b' from rhodecode.lib.str_utils import safe'
 from rhodecode.lib.hash_utils import sha1_safe
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.nodes import FileNode
+from rhodecode.lib.base import bootstrap_config
 from rhodecode.tests import (
-    login_user_session, get_new_dir, utils, TESTS_TMP_PATH,
-    TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR2_LOGIN,
-    TEST_USER_REGULAR_PASS)
-from rhodecode.tests.utils import CustomTestApp, set_anonymous_access
-from rhodecode.tests.fixture import Fixture
+    login_user_session,
+    get_new_dir,
+    utils,
+    TESTS_TMP_PATH,
+    TEST_USER_ADMIN_LOGIN,
+    TEST_USER_REGULAR_LOGIN,
+    TEST_USER_REGULAR2_LOGIN,
+    TEST_USER_REGULAR_PASS,
+    console_printer,
+)
+from rhodecode.tests.utils import set_anonymous_access
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.config import utils as config_utils
 
 log = logging.getLogger(__name__)
@@ -76,36 +93,7 b' def cmp(a, b):'
     return (a > b) - (a < b)
 
 
[e-mail](scope='session', autouse=True)
-def activate_example_rcextensions(request):
-    """
-    Patch in an example rcextensions module which verifies passed in kwargs.
-    """
-    from rhodecode.config import rcextensions
-
-    old_extensions = rhodecode.EXTENSIONS
-    rhodecode.EXTENSIONS = rcextensions
-    rhodecode.EXTENSIONS.calls = collections.defaultdict(list)
-
-    @request.addfinalizer
-    def cleanup():
-        rhodecode.EXTENSIONS = old_extensions
-
-
[e-mail]()
-def capture_rcextensions():
-    """
-    Returns the recorded calls to entry points in rcextensions.
-    """
-    calls = rhodecode.EXTENSIONS.calls
-    calls.clear()
-    # Note: At this moment, it is still the empty dict, but that will
-    # be filled during the test run and since it is a reference this
-    # is enough to make it work.
-    return calls
-
-
[e-mail](scope='session')
[e-mail](scope="session")
 def http_environ_session():
     """
     Allow to use "http_environ" in session scope.
@@ -117,7 +105,31 b' def plain_http_host_stub():'
     """
     Value of HTTP_HOST in the test run.
     """
-    return 'example.com:80'
+    return "example.com:80"
+
+
+def plain_config_stub(request, request_stub):
+    """
+    Set up pyramid.testing and return the Configurator.
+    """
+
+    config = bootstrap_config(request=request_stub)
+
+    @request.addfinalizer
+    def cleanup():
+        pyramid.testing.tearDown()
+
+    return config
+
+
+def plain_request_stub():
+    """
+    Stub request object.
+    """
+    from rhodecode.lib.base import bootstrap_request
+
+    _request = bootstrap_request(scheme="https")
+    return _request
 
 
 @pytest.fixture()
@@ -132,7 +144,7 b' def plain_http_host_only_stub():'
     """
     Value of HTTP_HOST in the test run.
     """
-    return plain_http_host_stub().split(':')[0]
+    return plain_http_host_stub().split(":")[0]
 
 
 @pytest.fixture()
@@ -147,33 +159,21 b' def plain_http_environ():'
     """
     HTTP extra environ keys.
 
-    User by the test application and as well for setting up the pylons
+    Used by the test application and as well for setting up the pylons
     environment. In the case of the fixture "app" it should be possible
     to override this for a specific test case.
     """
     return {
-        'SERVER_NAME': plain_http_host_only_stub(),
-        'SERVER_PORT': plain_http_host_stub().split(':')[1],
-        'HTTP_HOST': plain_http_host_stub(),
-        'HTTP_USER_AGENT': 'rc-test-agent',
-        'REQUEST_METHOD': 'GET'
+        "SERVER_NAME": plain_http_host_only_stub(),
+        "SERVER_PORT": plain_http_host_stub().split(":")[1],
+        "HTTP_HOST": plain_http_host_stub(),
+        "HTTP_USER_AGENT": "rc-test-agent",
+        "REQUEST_METHOD": "GET",
     }
 
 
[e-mail]()
-def http_environ():
-    """
-    HTTP extra environ keys.
-
-    User by the test application and as well for setting up the pylons
-    environment. In the case of the fixture "app" it should be possible
-    to override this for a specific test case.
-    """
-    return plain_http_environ()
-
-
[e-mail](scope='session')
-def baseapp(ini_config, vcsserver, http_environ_session):
[e-mail](scope="session")
+def baseapp(request, ini_config, http_environ_session, available_port_factory, vcsserver_factory, celery_factory):
     from rhodecode.lib.config_utils import get_app_config
     from rhodecode.config.middleware import make_pyramid_app
 
@@ -181,22 +181,41 b' def baseapp(ini_config, vcsserver, http_'
     pyramid.paster.setup_logging(ini_config)
 
     settings = get_app_config(ini_config)
-    app = make_pyramid_app({'__file__': ini_config}, **settings)
+    store_dir = os.path.dirname(ini_config)
+
+    # start vcsserver
+    _vcsserver_port = available_port_factory()
+    vcsserver_instance = vcsserver_factory(
+        request,
+        store_dir=store_dir,
+        port=_vcsserver_port,
+        info_prefix="base-app-"
+    )
+
+    settings["vcs.server"] = vcsserver_instance.bind_addr
 
-    return app
+    # we skip setting store_dir for baseapp, it's internally set via testing rhodecode.ini
+    # settings['repo_store.path'] = str(store_dir)
+    console_printer(f' :warning: [green]pytest-setup[/green] Starting base pyramid-app: {ini_config}')
+    pyramid_baseapp = make_pyramid_app({"__file__": ini_config}, **settings)
+
+    # start celery
+    celery_factory(
+        request,
+        store_dir=store_dir,
+        port=None,
+        info_prefix="base-app-",
+        overrides=(
+            {'handler_console': {'level': 'DEBUG'}},
+            {'app:main': {'vcs.server': vcsserver_instance.bind_addr}},
+            {'app:main': {'repo_store.path': store_dir}}
+        )
+    )
+
+    return pyramid_baseapp
 
 
[e-mail](scope='function')
-def app(request, config_stub, baseapp, http_environ):
-    app = CustomTestApp(
-        baseapp,
-        extra_environ=http_environ)
-    if request.cls:
-        request.cls.app = app
-    return app
-
-
[e-mail](scope='session')
[e-mail](scope="session")
 def app_settings(baseapp, ini_config):
     """
     Settings dictionary used to create the app.
@@ -207,19 +226,19 b' def app_settings(baseapp, ini_config):'
     return baseapp.config.get_settings()
 
 
[e-mail](scope='session')
[e-mail](scope="session")
 def db_connection(ini_settings):
     # Initialize the database connection.
     config_utils.initialize_database(ini_settings)
 
 
-LoginData = collections.namedtuple('LoginData', ('csrf_token', 'user'))
+LoginData = collections.namedtuple("LoginData", ("csrf_token", "user"))
 
 
 def _autologin_user(app, *args):
     session = login_user_session(app, *args)
     csrf_token = rhodecode.lib.auth.get_csrf_token(session)
-    return LoginData(csrf_token, session['rhodecode_user'])
+    return LoginData(csrf_token, session["rhodecode_user"])
 
 
 @pytest.fixture()
@@ -235,18 +254,17 b' def autologin_regular_user(app):'
     """
     Utility fixture which makes sure that the regular user is logged in
     """
-    return _autologin_user(
-        app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
+    return _autologin_user(app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
 
 
[e-mail](scope='function')
[e-mail](scope="function")
 def csrf_token(request, autologin_user):
     return autologin_user.csrf_token
 
 
[e-mail](scope='function')
[e-mail](scope="function")
 def xhr_header(request):
-    return {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
+    return {"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"}
 
 
 @pytest.fixture()
@@ -257,18 +275,18 b' def real_crypto_backend(monkeypatch):'
     During the test run the crypto backend is replaced with a faster
     implementation based on the MD5 algorithm.
     """
-    monkeypatch.setattr(rhodecode, 'is_test', False)
+    monkeypatch.setattr(rhodecode, "is_test", False)
 
 
[e-mail](scope='class')
[e-mail](scope="class")
 def index_location(request, baseapp):
-    index_location = baseapp.config.get_settings()['search.location']
+    index_location = baseapp.config.get_settings()["search.location"]
     if request.cls:
         request.cls.index_location = index_location
     return index_location
 
 
[e-mail](scope='session', autouse=True)
[e-mail](scope="session", autouse=True)
 def tests_tmp_path(request):
     """
     Create temporary directory to be used during the test session.
@@ -276,7 +294,8 b' def tests_tmp_path(request):'
     if not os.path.exists(TESTS_TMP_PATH):
         os.makedirs(TESTS_TMP_PATH)
 
-    if not request.config.getoption('--keep-tmp-path'):
+    if not request.config.getoption("--keep-tmp-path"):
+
         @request.addfinalizer
         def remove_tmp_path():
             shutil.rmtree(TESTS_TMP_PATH)
@@ -291,7 +310,7 b' def test_repo_group(request):'
     usage automatically
     """
     fixture = Fixture()
-    repogroupid = 'test_repo_group_%s' % str(time.time()).replace('.', '')
+    repogroupid = "test_repo_group_%s" % str(time.time()).replace(".", "")
     repo_group = fixture.create_repo_group(repogroupid)
 
     def _cleanup():
@@ -308,7 +327,7 b' def test_user_group(request):'
     usage automatically
     """
     fixture = Fixture()
-    usergroupid = 'test_user_group_%s' % str(time.time()).replace('.', '')
+    usergroupid = "test_user_group_%s" % str(time.time()).replace(".", "")
     user_group = fixture.create_user_group(usergroupid)
 
     def _cleanup():
@@ -318,7 +337,7 b' def test_user_group(request):'
     return user_group
 
 
[e-mail](scope='session')
[e-mail](scope="session")
 def test_repo(request):
     container = TestRepoContainer()
     request.addfinalizer(container._cleanup)
@@ -340,9 +359,9 b' class TestRepoContainer(object):'
     """
 
     dump_extractors = {
-        'git': utils.extract_git_repo_from_dump,
-        'hg': utils.extract_hg_repo_from_dump,
-        'svn': utils.extract_svn_repo_from_dump,
+        "git": utils.extract_git_repo_from_dump,
+        "hg": utils.extract_hg_repo_from_dump,
+        "svn": utils.extract_svn_repo_from_dump,
     }
 
     def __init__(self):
@@ -358,7 +377,7 b' class TestRepoContainer(object):'
         return Repository.get(self._repos[key])
 
     def _create_repo(self, dump_name, backend_alias, config):
-        repo_name = f'{backend_alias}-{dump_name}'
+        repo_name = f"{backend_alias}-{dump_name}"
         backend = get_backend(backend_alias)
         dump_extractor = self.dump_extractors[backend_alias]
         repo_path = dump_extractor(dump_name, repo_name)
@@ -375,19 +394,17 b' class TestRepoContainer(object):'
             self._fixture.destroy_repo(repo_name)
 
 
-def backend_base(request, backend_alias, baseapp, test_repo):
-    if backend_alias not in request.config.getoption('--backends'):
-        pytest.skip("Backend %s not selected." % (backend_alias, ))
+def backend_base(request, backend_alias, test_repo):
+    if backend_alias not in request.config.getoption("--backends"):
+        pytest.skip(f"Backend {backend_alias} not selected.")
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
-    repo_name = 'vcs_test_%s' % (backend_alias, )
+    repo_name = "vcs_test_%s" % (backend_alias,)
     backend = Backend(
-        alias=backend_alias,
-        repo_name=repo_name,
-        test_name=request.node.name,
-        test_repo_container=test_repo)
+        alias=backend_alias, repo_name=repo_name, test_name=request.node.name, test_repo_container=test_repo
+    )
     request.addfinalizer(backend.cleanup)
     return backend
 
@@ -404,22 +421,22 b' def backend(request, backend_alias, base'
     for specific backends. This is intended as a utility for incremental
     development of a new backend implementation.
     """
-    return backend_base(request, backend_alias, baseapp, test_repo)
+    return backend_base(request, backend_alias, test_repo)
 
 
 @pytest.fixture()
 def backend_git(request, baseapp, test_repo):
-    return backend_base(request, 'git', baseapp, test_repo)
+    return backend_base(request, "git", test_repo)
 
 
 @pytest.fixture()
 def backend_hg(request, baseapp, test_repo):
-    return backend_base(request, 'hg', baseapp, test_repo)
+    return backend_base(request, "hg", test_repo)
 
 
 @pytest.fixture()
 def backend_svn(request, baseapp, test_repo):
-    return backend_base(request, 'svn', baseapp, test_repo)
+    return backend_base(request, "svn", test_repo)
 
 
 @pytest.fixture()
@@ -467,9 +484,9 b' class Backend(object):'
     session.
     """
 
-    invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
+    invalid_repo_name = re.compile(r"[^0-9a-zA-Z]+")
     _master_repo = None
-    _master_repo_path = ''
+    _master_repo_path = ""
     _commit_ids = {}
 
     def __init__(self, alias, repo_name, test_name, test_repo_container):
@@ -500,6 +517,7 b' class Backend(object):'
         last repo which has been created with `create_repo`.
         """
         from rhodecode.model.db import Repository
+
         return Repository.get_by_repo_name(self.repo_name)
 
     @property
@@ -517,9 +535,7 b' class Backend(object):'
         which can serve as the base to create a new commit on top of it.
         """
         vcsrepo = self.repo.scm_instance()
-        head_id = (
-            vcsrepo.DEFAULT_BRANCH_NAME or
-            vcsrepo.commit_ids[-1])
+        head_id = vcsrepo.DEFAULT_BRANCH_NAME or vcsrepo.commit_ids[-1]
         return head_id
 
     @property
@@ -543,9 +559,7 b' class Backend(object):'
 
         return self._commit_ids
 
-    def create_repo(
-            self, commits=None, number_of_commits=0, heads=None,
-            name_suffix='', bare=False, **kwargs):
+    def create_repo(self, commits=None, number_of_commits=0, heads=None, name_suffix="", bare=False, **kwargs):
         """
         Create a repository and record it for later cleanup.
 
@@ -559,13 +573,10 b' class Backend(object):'
         :param bare: set a repo as bare (no checkout)
         """
         self.repo_name = self._next_repo_name() + name_suffix
-        repo = self._fixture.create_repo(
-            self.repo_name, repo_type=self.alias, bare=bare, **kwargs)
+        repo = self._fixture.create_repo(self.repo_name, repo_type=self.alias, bare=bare, **kwargs)
         self._cleanup_repos.append(repo.repo_name)
 
-        commits = commits or [
-            {'message': f'Commit {x} of {self.repo_name}'}
-            for x in range(number_of_commits)]
+        commits = commits or [{"message": f"Commit {x} of {self.repo_name}"} for x in range(number_of_commits)]
         vcs_repo = repo.scm_instance()
         vcs_repo.count()
         self._add_commits_to_repo(vcs_repo, commits)
@@ -579,7 +590,7 b' class Backend(object):'
         Make sure that repo contains all commits mentioned in `heads`
         """
         vcsrepo = repo.scm_instance()
-        vcsrepo.config.clear_section('hooks')
+        vcsrepo.config.clear_section("hooks")
         commit_ids = [self._commit_ids[h] for h in heads]
         if do_fetch:
             vcsrepo.fetch(self._master_repo_path, commit_ids=commit_ids)
@@ -592,21 +603,22 b' class Backend(object):'
         self._cleanup_repos.append(self.repo_name)
         return repo
 
-    def new_repo_name(self, suffix=''):
+    def new_repo_name(self, suffix=""):
         self.repo_name = self._next_repo_name() + suffix
         self._cleanup_repos.append(self.repo_name)
         return self.repo_name
 
     def _next_repo_name(self):
-        return "%s_%s" % (
-            self.invalid_repo_name.sub('_', self._test_name), len(self._cleanup_repos))
+        return "%s_%s" % (self.invalid_repo_name.sub("_", self._test_name), len(self._cleanup_repos))
 
-    def ensure_file(self, filename, content=b'Test content\n'):
+    def ensure_file(self, filename, content=b"Test content\n"):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         commits = [
-            {'added': [
-                FileNode(filename, content=content),
-            ]},
+            {
+                "added": [
+                    FileNode(filename, content=content),
+                ]
+            },
         ]
         self._add_commits_to_repo(self.repo.scm_instance(), commits)
 
@@ -627,11 +639,11 b' class Backend(object):'
         self._commit_ids = commit_ids
 
         # Creating refs for Git to allow fetching them from remote repository
-        if self.alias == 'git':
+        if self.alias == "git":
             refs = {}
             for message in self._commit_ids:
-                cleanup_message = message.replace(' ', '')
-                ref_name = f'refs/test-refs/{cleanup_message}'
+                cleanup_message = message.replace(" ", "")
+                ref_name = f"refs/test-refs/{cleanup_message}"
                 refs[ref_name] = self._commit_ids[message]
             self._create_refs(repo, refs)
 
@@ -645,7 +657,7 b' class VcsBackend(object):'
     Represents the test configuration for one supported vcs backend.
     """
 
-    invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
+    invalid_repo_name = re.compile(r"[^0-9a-zA-Z]+")
 
     def __init__(self, alias, repo_path, test_name, test_repo_container):
         self.alias = alias
@@ -658,7 +670,7 b' class VcsBackend(object):'
         return self._test_repo_container(key, self.alias).scm_instance()
 
     def __repr__(self):
-        return f'{self.__class__.__name__}(alias={self.alias}, repo={self._repo_path})'
+        return f"{self.__class__.__name__}(alias={self.alias}, repo={self._repo_path})"
 
     @property
     def repo(self):
@@ -676,8 +688,7 b' class VcsBackend(object):'
         """
         return get_backend(self.alias)
 
-    def create_repo(self, commits=None, number_of_commits=0, _clone_repo=None,
-                    bare=False):
+    def create_repo(self, commits=None, number_of_commits=0, _clone_repo=None, bare=False):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         repo_class = get_backend(self.alias)
@@ -687,9 +698,7 b' class VcsBackend(object):'
         repo = repo_class(self._repo_path, create=True, src_url=src_url, bare=bare)
         self._cleanup_repos.append(repo)
 
-        commits = commits or [
-            {'message': 'Commit %s of %s' % (x, repo_name)}
-            for x in range(number_of_commits)]
+        commits = commits or [{"message": "Commit %s of %s" % (x, repo_name)} for x in range(number_of_commits)]
         _add_commits_to_repo(repo, commits)
         return repo
 
@@ -706,38 +715,30 b' class VcsBackend(object):'
         return self._repo_path
 
     def _next_repo_name(self):
+        return "{}_{}".format(self.invalid_repo_name.sub("_", self._test_name), len(self._cleanup_repos))
 
-        return "{}_{}".format(
-            self.invalid_repo_name.sub('_', self._test_name),
-            len(self._cleanup_repos)
-        )
-
-    def add_file(self, repo, filename, content='Test content\n'):
+    def add_file(self, repo, filename, content="Test content\n"):
         imc = repo.in_memory_commit
         imc.add(FileNode(safe_bytes(filename), content=safe_bytes(content)))
-        imc.commit(
-            message='Automatic commit from vcsbackend fixture',
-            author='Automatic <[e-mail]>')
+        imc.commit(message="Automatic commit from vcsbackend fixture", author="Automatic <[e-mail]>")
 
-    def ensure_file(self, filename, content='Test content\n'):
+    def ensure_file(self, filename, content="Test content\n"):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         self.add_file(self.repo, filename, content)
 
 
 def vcsbackend_base(request, backend_alias, tests_tmp_path, baseapp, test_repo) -> VcsBackend:
-    if backend_alias not in request.config.getoption('--backends'):
-        pytest.skip("Backend %s not selected." % (backend_alias, ))
+    if backend_alias not in request.config.getoption("--backends"):
+        pytest.skip("Backend %s not selected." % (backend_alias,))
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
-    repo_name = f'vcs_test_{backend_alias}'
+    repo_name = f"vcs_test_{backend_alias}"
     repo_path = os.path.join(tests_tmp_path, repo_name)
     backend = VcsBackend(
-        alias=backend_alias,
-        repo_path=repo_path,
-        test_name=request.node.name,
-        test_repo_container=test_repo)
+        alias=backend_alias, repo_path=repo_path, test_name=request.node.name, test_repo_container=test_repo
+    )
     request.addfinalizer(backend.cleanup)
     return backend
 
@@ -758,17 +759,17 b' def vcsbackend(request, backend_alias, t'
 
 @pytest.fixture()
 def vcsbackend_git(request, tests_tmp_path, baseapp, test_repo):
-    return vcsbackend_base(request, 'git', tests_tmp_path, baseapp, test_repo)
+    return vcsbackend_base(request, "git", tests_tmp_path, baseapp, test_repo)
 
 
 @pytest.fixture()
 def vcsbackend_hg(request, tests_tmp_path, baseapp, test_repo):
-    return vcsbackend_base(request, 'hg', tests_tmp_path, baseapp, test_repo)
+    return vcsbackend_base(request, "hg", tests_tmp_path, baseapp, test_repo)
 
 
 @pytest.fixture()
 def vcsbackend_svn(request, tests_tmp_path, baseapp, test_repo):
-    return vcsbackend_base(request, 'svn', tests_tmp_path, baseapp, test_repo)
+    return vcsbackend_base(request, "svn", tests_tmp_path, baseapp, test_repo)
 
 
 @pytest.fixture()
@@ -789,29 +790,28 b' def _add_commits_to_repo(vcs_repo, commi'
     imc = vcs_repo.in_memory_commit
 
     for idx, commit in enumerate(commits):
-        message = str(commit.get('message', f'Commit {idx}'))
+        message = str(commit.get("message", f"Commit {idx}"))
 
-        for node in commit.get('added', []):
+        for node in commit.get("added", []):
             imc.add(FileNode(safe_bytes(node.path), content=node.content))
-        for node in commit.get('changed', []):
+        for node in commit.get("changed", []):
             imc.change(FileNode(safe_bytes(node.path), content=node.content))
-        for node in commit.get('removed', []):
+        for node in commit.get("removed", []):
             imc.remove(FileNode(safe_bytes(node.path)))
 
-        parents = [
-            vcs_repo.get_commit(commit_id=commit_ids[p])
-            for p in commit.get('parents', [])]
+        parents = [vcs_repo.get_commit(commit_id=commit_ids[p]) for p in commit.get("parents", [])]
 
-        operations = ('added', 'changed', 'removed')
+        operations = ("added", "changed", "removed")
         if not any((commit.get(o) for o in operations)):
-            imc.add(FileNode(b'file_%b' % safe_bytes(str(idx)), content=safe_bytes(message)))
+            imc.add(FileNode(b"file_%b" % safe_bytes(str(idx)), content=safe_bytes(message)))
 
         commit = imc.commit(
             message=message,
-            author=str(commit.get('author', 'Automatic <[e-mail]>')),
-            date=commit.get('date'),
-            branch=commit.get('branch'),
-            parents=parents)
+            author=str(commit.get("author", "Automatic <[e-mail]>")),
+            date=commit.get("date"),
+            branch=commit.get("branch"),
+            parents=parents,
+        )
 
         commit_ids[commit.message] = commit.raw_id
 
@@ -842,14 +842,14 b' class RepoServer(object):'
         self._cleanup_servers = []
 
     def serve(self, vcsrepo):
-        if vcsrepo.alias != 'svn':
+        if vcsrepo.alias != "svn":
             raise TypeError("Backend %s not supported" % vcsrepo.alias)
 
         proc = subprocess.Popen(
-            ['svnserve', '-d', '--foreground', '--listen-host', 'localhost',
-             '--root', vcsrepo.path])
+            ["svnserve", "-d", "--foreground", "--listen-host", "localhost", "--root", vcsrepo.path]
+        )
         self._cleanup_servers.append(proc)
-        self.url = 'svn://localhost'
+        self.url = "svn://localhost"
 
     def cleanup(self):
         for proc in self._cleanup_servers:
@@ -874,7 +874,6 b' def pr_util(backend, request, config_stu'
 
 
 class PRTestUtility(object):
-
     pull_request = None
     pull_request_id = None
     mergeable_patcher = None
@@ -886,48 +885,55 b' class PRTestUtility(object):'
         self.backend = backend
 
     def create_pull_request(
-            self, commits=None, target_head=None, source_head=None,
-            revisions=None, approved=False, author=None, mergeable=False,
-            enable_notifications=True, name_suffix='', reviewers=None, observers=None,
-            title="Test", description="Description"):
+        self,
+        commits=None,
+        target_head=None,
+        source_head=None,
+        revisions=None,
+        approved=False,
+        author=None,
+        mergeable=False,
+        enable_notifications=True,
+        name_suffix="",
+        reviewers=None,
+        observers=None,
+        title="Test",
+        description="Description",
+    ):
         self.set_mergeable(mergeable)
         if not enable_notifications:
             # mock notification side effect
-            self.notification_patcher = mock.patch(
-                'rhodecode.model.notification.NotificationModel.create')
+            self.notification_patcher = mock.patch("rhodecode.model.notification.NotificationModel.create")
             self.notification_patcher.start()
 
         if not self.pull_request:
             if not commits:
                 commits = [
-                    {'message': 'c1'},
-                    {'message': 'c2'},
-                    {'message': 'c3'},
+                    {"message": "c1"},
+                    {"message": "c2"},
+                    {"message": "c3"},
                 ]
-                target_head = 'c1'
-                source_head = 'c2'
-                revisions = ['c2']
+                target_head = "c1"
+                source_head = "c2"
+                revisions = ["c2"]
 
             self.commit_ids = self.backend.create_master_repo(commits)
-            self.target_repository = self.backend.create_repo(
-                heads=[target_head], name_suffix=name_suffix)
-            self.source_repository = self.backend.create_repo(
-                heads=[source_head], name_suffix=name_suffix)
-            self.author = author or UserModel().get_by_username(
-                TEST_USER_ADMIN_LOGIN)
+            self.target_repository = self.backend.create_repo(heads=[target_head], name_suffix=name_suffix)
+            self.source_repository = self.backend.create_repo(heads=[source_head], name_suffix=name_suffix)
+            self.author = author or UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
 
             model = PullRequestModel()
             self.create_parameters = {
-                'created_by': self.author,
-                'source_repo': self.source_repository.repo_name,
-                'source_ref': self._default_branch_reference(source_head),
-                'target_repo': self.target_repository.repo_name,
-                'target_ref': self._default_branch_reference(target_head),
-                'revisions': [self.commit_ids[r] for r in revisions],
-                'reviewers': reviewers or self._get_reviewers(),
-                'observers': observers or self._get_observers(),
-                'title': title,
-                'description': description,
+                "created_by": self.author,
+                "source_repo": self.source_repository.repo_name,
+                "source_ref": self._default_branch_reference(source_head),
+                "target_repo": self.target_repository.repo_name,
+                "target_ref": self._default_branch_reference(target_head),
+                "revisions": [self.commit_ids[r] for r in revisions],
+                "reviewers": reviewers or self._get_reviewers(),
+                "observers": observers or self._get_observers(),
+                "title": title,
+                "description": description,
             }
             self.pull_request = model.create(**self.create_parameters)
             assert model.get_versions(self.pull_request) == []
@@ -943,9 +949,7 b' class PRTestUtility(object):'
         return self.pull_request
 
     def approve(self):
-        self.create_status_votes(
-            ChangesetStatus.STATUS_APPROVED,
-            *self.pull_request.reviewers)
+        self.create_status_votes(ChangesetStatus.STATUS_APPROVED, *self.pull_request.reviewers)
 
     def close(self):
         PullRequestModel().close_pull_request(self.pull_request, self.author)
@@ -953,28 +957,26 b' class PRTestUtility(object):'
     def _default_branch_reference(self, commit_message, branch: str = None) -> str:
         default_branch = branch or self.backend.default_branch_name
         message = self.commit_ids[commit_message]
-        reference = f'branch:{default_branch}:{message}'
+        reference = f"branch:{default_branch}:{message}"
 
         return reference
 
     def _get_reviewers(self):
         role = PullRequestReviewers.ROLE_REVIEWER
         return [
-            (TEST_USER_REGULAR_LOGIN, ['default1'], False, role, []),
-            (TEST_USER_REGULAR2_LOGIN, ['default2'], False, role, []),
+            (TEST_USER_REGULAR_LOGIN, ["default1"], False, role, []),
+            (TEST_USER_REGULAR2_LOGIN, ["default2"], False, role, []),
         ]
 
     def _get_observers(self):
-        return [
-
-        ]
+        return []
 
     def update_source_repository(self, head=None, do_fetch=False):
-        heads = [head or 'c3']
+        heads = [head or "c3"]
         self.backend.pull_heads(self.source_repository, heads=heads, do_fetch=do_fetch)
 
     def update_target_repository(self, head=None, do_fetch=False):
-        heads = [head or 'c3']
+        heads = [head or "c3"]
         self.backend.pull_heads(self.target_repository, heads=heads, do_fetch=do_fetch)
 
     def set_pr_target_ref(self, ref_type: str = "branch", ref_name: str = "branch", ref_commit_id: str = "") -> str:
@@ -1004,7 +1006,7 b' class PRTestUtility(object):'
         # TODO: johbo: Git and Mercurial have an inconsistent vcs api here,
         # remove the if once that's sorted out.
         if self.backend.alias == "git":
-            kwargs = {'branch_name': self.backend.default_branch_name}
+            kwargs = {"branch_name": self.backend.default_branch_name}
         else:
             kwargs = {}
         source_vcs.strip(removed_commit_id, **kwargs)
@@ -1015,10 +1017,8 b' class PRTestUtility(object):'
 
     def create_comment(self, linked_to=None):
         comment = CommentsModel().create(
-            text="Test comment",
-            repo=self.target_repository.repo_name,
-            user=self.author,
-            pull_request=self.pull_request)
+            text="Test comment", repo=self.target_repository.repo_name, user=self.author, pull_request=self.pull_request
+        )
         assert comment.pull_request_version_id is None
 
         if linked_to:
@@ -1026,15 +1026,15 b' class PRTestUtility(object):'
 
         return comment
 
-    def create_inline_comment(
-            self, linked_to=None, line_no='n1', file_path='file_1'):
+    def create_inline_comment(self, linked_to=None, line_no="n1", file_path="file_1"):
         comment = CommentsModel().create(
             text="Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             line_no=line_no,
             f_path=file_path,
-            pull_request=self.pull_request)
+            pull_request=self.pull_request,
+        )
         assert comment.pull_request_version_id is None
 
         if linked_to:
@@ -1044,25 +1044,20 b' class PRTestUtility(object):'
 
     def create_version_of_pull_request(self):
         pull_request = self.create_pull_request()
-        version = PullRequestModel()._create_version_from_snapshot(
-            pull_request)
+        version = PullRequestModel()._create_version_from_snapshot(pull_request)
         return version
 
     def create_status_votes(self, status, *reviewers):
         for reviewer in reviewers:
             ChangesetStatusModel().set_status(
-                repo=self.pull_request.target_repo,
-                status=status,
-                user=reviewer.user_id,
-                pull_request=self.pull_request)
+                repo=self.pull_request.target_repo, status=status, user=reviewer.user_id, pull_request=self.pull_request
+            )
 
     def set_mergeable(self, value):
         if not self.mergeable_patcher:
-            self.mergeable_patcher = mock.patch.object(
-                VcsSettingsModel, 'get_general_settings')
+            self.mergeable_patcher = mock.patch.object(VcsSettingsModel, "get_general_settings")
             self.mergeable_mock = self.mergeable_patcher.start()
-        self.mergeable_mock.return_value = {
-            'rhodecode_pr_merge_enabled': value}
+        self.mergeable_mock.return_value = {"rhodecode_pr_merge_enabled": value}
 
     def cleanup(self):
         # In case the source repository is already cleaned up, the pull
@@ -1109,7 +1104,6 b' def user_util(request, db_connection):'
 
 # TODO: johbo: Split this up into utilities per domain or something similar
 class UserUtility(object):
-
     def __init__(self, test_name="test"):
         self._test_name = self._sanitize_name(test_name)
         self.fixture = Fixture()
@@ -1126,37 +1120,29 b' class UserUtility(object):'
         self.user_permissions = []
 
     def _sanitize_name(self, name):
-        for char in ['[', ']']:
-            name = name.replace(char, '_')
+        for char in ["[", "]"]:
+            name = name.replace(char, "_")
         return name
 
-    def create_repo_group(
-            self, owner=TEST_USER_ADMIN_LOGIN, auto_cleanup=True):
-        group_name = "{prefix}_repogroup_{count}".format(
-            prefix=self._test_name,
-            count=len(self.repo_group_ids))
-        repo_group = self.fixture.create_repo_group(
-            group_name, cur_user=owner)
+    def create_repo_group(self, owner=TEST_USER_ADMIN_LOGIN, auto_cleanup=True):
+        group_name = "{prefix}_repogroup_{count}".format(prefix=self._test_name, count=len(self.repo_group_ids))
+        repo_group = self.fixture.create_repo_group(group_name, cur_user=owner)
         if auto_cleanup:
             self.repo_group_ids.append(repo_group.group_id)
         return repo_group
 
-    def create_repo(self, owner=TEST_USER_ADMIN_LOGIN, parent=None,
-                    auto_cleanup=True, repo_type='hg', bare=False):
-        repo_name = "{prefix}_repository_{count}".format(
-            prefix=self._test_name,
-            count=len(self.repos_ids))
+    def create_repo(self, owner=TEST_USER_ADMIN_LOGIN, parent=None, auto_cleanup=True, repo_type="hg", bare=False):
+        repo_name = "{prefix}_repository_{count}".format(prefix=self._test_name, count=len(self.repos_ids))
 
         repository = self.fixture.create_repo(
-            repo_name, cur_user=owner, repo_group=parent, repo_type=repo_type, bare=bare)
+            repo_name, cur_user=owner, repo_group=parent, repo_type=repo_type, bare=bare
+        )
         if auto_cleanup:
             self.repos_ids.append(repository.repo_id)
         return repository
 
     def create_user(self, auto_cleanup=True, **kwargs):
-        user_name = "{prefix}_user_{count}".format(
-            prefix=self._test_name,
-            count=len(self.user_ids))
+        user_name = "{prefix}_user_{count}".format(prefix=self._test_name, count=len(self.user_ids))
         user = self.fixture.create_user(user_name, **kwargs)
         if auto_cleanup:
             self.user_ids.append(user.user_id)
@@ -1171,13 +1157,9 b' class UserUtility(object):'
         user_group = self.create_user_group(members=[user])
         return user, user_group
 
-    def create_user_group(self, owner=TEST_USER_ADMIN_LOGIN, members=None,
-                          auto_cleanup=True, **kwargs):
-        group_name = "{prefix}_usergroup_{count}".format(
-            prefix=self._test_name,
-            count=len(self.user_group_ids))
-        user_group = self.fixture.create_user_group(
-            group_name, cur_user=owner, **kwargs)
+    def create_user_group(self, owner=TEST_USER_ADMIN_LOGIN, members=None, auto_cleanup=True, **kwargs):
+        group_name = "{prefix}_usergroup_{count}".format(prefix=self._test_name, count=len(self.user_group_ids))
+        user_group = self.fixture.create_user_group(group_name, cur_user=owner, **kwargs)
 
         if auto_cleanup:
             self.user_group_ids.append(user_group.users_group_id)
@@ -1190,52 +1172,34 b' class UserUtility(object):'
         self.inherit_default_user_permissions(user_name, False)
         self.user_permissions.append((user_name, permission_name))
 
-    def grant_user_permission_to_repo_group(
-            self, repo_group, user, permission_name):
-        permission = RepoGroupModel().grant_user_permission(
-            repo_group, user, permission_name)
-        self.user_repo_group_permission_ids.append(
-            (repo_group.group_id, user.user_id))
+    def grant_user_permission_to_repo_group(self, repo_group, user, permission_name):
+        permission = RepoGroupModel().grant_user_permission(repo_group, user, permission_name)
+        self.user_repo_group_permission_ids.append((repo_group.group_id, user.user_id))
         return permission
 
-    def grant_user_group_permission_to_repo_group(
-            self, repo_group, user_group, permission_name):
-        permission = RepoGroupModel().grant_user_group_permission(
-            repo_group, user_group, permission_name)
-        self.user_group_repo_group_permission_ids.append(
-            (repo_group.group_id, user_group.users_group_id))
+    def grant_user_group_permission_to_repo_group(self, repo_group, user_group, permission_name):
+        permission = RepoGroupModel().grant_user_group_permission(repo_group, user_group, permission_name)
+        self.user_group_repo_group_permission_ids.append((repo_group.group_id, user_group.users_group_id))
         return permission
 
-    def grant_user_permission_to_repo(
-            self, repo, user, permission_name):
-        permission = RepoModel().grant_user_permission(
-            repo, user, permission_name)
-        self.user_repo_permission_ids.append(
-            (repo.repo_id, user.user_id))
+    def grant_user_permission_to_repo(self, repo, user, permission_name):
+        permission = RepoModel().grant_user_permission(repo, user, permission_name)
+        self.user_repo_permission_ids.append((repo.repo_id, user.user_id))
         return permission
 
-    def grant_user_group_permission_to_repo(
-            self, repo, user_group, permission_name):
-        permission = RepoModel().grant_user_group_permission(
-            repo, user_group, permission_name)
-        self.user_group_repo_permission_ids.append(
-            (repo.repo_id, user_group.users_group_id))
+    def grant_user_group_permission_to_repo(self, repo, user_group, permission_name):
+        permission = RepoModel().grant_user_group_permission(repo, user_group, permission_name)
+        self.user_group_repo_permission_ids.append((repo.repo_id, user_group.users_group_id))
         return permission
 
-    def grant_user_permission_to_user_group(
-            self, target_user_group, user, permission_name):
-        permission = UserGroupModel().grant_user_permission(
-            target_user_group, user, permission_name)
-        self.user_user_group_permission_ids.append(
-            (target_user_group.users_group_id, user.user_id))
+    def grant_user_permission_to_user_group(self, target_user_group, user, permission_name):
+        permission = UserGroupModel().grant_user_permission(target_user_group, user, permission_name)
+        self.user_user_group_permission_ids.append((target_user_group.users_group_id, user.user_id))
         return permission
 
-    def grant_user_group_permission_to_user_group(
-            self, target_user_group, user_group, permission_name):
-        permission = UserGroupModel().grant_user_group_permission(
-            target_user_group, user_group, permission_name)
-        self.user_group_user_group_permission_ids.append(
-            (target_user_group.users_group_id, user_group.users_group_id))
+    def grant_user_group_permission_to_user_group(self, target_user_group, user_group, permission_name):
+        permission = UserGroupModel().grant_user_group_permission(target_user_group, user_group, permission_name)
+        self.user_group_user_group_permission_ids.append((target_user_group.users_group_id, user_group.users_group_id))
         return permission
 
     def revoke_user_permission(self, user_name, permission_name):
@@ -1285,14 +1249,11 b' class UserUtility(object):'
             """
             first_group = RepoGroup.get(first_group_id)
             second_group = RepoGroup.get(second_group_id)
-            first_group_parts = (
-                len(first_group.group_name.split('/')) if first_group else 0)
-            second_group_parts = (
-                len(second_group.group_name.split('/')) if second_group else 0)
+            first_group_parts = len(first_group.group_name.split("/")) if first_group else 0
+            second_group_parts = len(second_group.group_name.split("/")) if second_group else 0
             return cmp(second_group_parts, first_group_parts)
 
-        sorted_repo_group_ids = sorted(
-            self.repo_group_ids, key=functools.cmp_to_key(_repo_group_compare))
+        sorted_repo_group_ids = sorted(self.repo_group_ids, key=functools.cmp_to_key(_repo_group_compare))
         for repo_group_id in sorted_repo_group_ids:
             self.fixture.destroy_repo_group(repo_group_id)
 
@@ -1308,16 +1269,11 b' class UserUtility(object):'
             """
             first_group = UserGroup.get(first_group_id)
             second_group = UserGroup.get(second_group_id)
-            first_group_parts = (
-                len(first_group.users_group_name.split('/'))
-                if first_group else 0)
-            second_group_parts = (
-                len(second_group.users_group_name.split('/'))
-                if second_group else 0)
+            first_group_parts = len(first_group.users_group_name.split("/")) if first_group else 0
+            second_group_parts = len(second_group.users_group_name.split("/")) if second_group else 0
             return cmp(second_group_parts, first_group_parts)
 
-        sorted_user_group_ids = sorted(
-            self.user_group_ids, key=functools.cmp_to_key(_user_group_compare))
+        sorted_user_group_ids = sorted(self.user_group_ids, key=functools.cmp_to_key(_user_group_compare))
         for user_group_id in sorted_user_group_ids:
             self.fixture.destroy_user_group(user_group_id)
 
@@ -1326,22 +1282,19 b' class UserUtility(object):'
             self.fixture.destroy_user(user_id)
 
 
[e-mail](scope='session')
[e-mail](scope="session")
 def testrun():
     return {
-        'uuid': uuid.uuid4(),
-        'start': datetime.datetime.utcnow().isoformat(),
-        'timestamp': int(time.time()),
+        "uuid": uuid.uuid4(),
+        "start": datetime.datetime.utcnow().isoformat(),
+        "timestamp": int(time.time()),
     }
 
 
 class AppenlightClient(object):
-
-    url_template = '{url}?protocol_version=0.5'
+    url_template = "{url}?protocol_version=0.5"
 
-    def __init__(
-            self, url, api_key, add_server=True, add_timestamp=True,
-            namespace=None, request=None, testrun=None):
+    def __init__(self, url, api_key, add_server=True, add_timestamp=True, namespace=None, request=None, testrun=None):
         self.url = self.url_template.format(url=url)
         self.api_key = api_key
         self.add_server = add_server
@@ -1362,40 +1315,41 b' class AppenlightClient(object):'
 
     def collect(self, data):
         if self.add_server:
-            data.setdefault('server', self.server)
+            data.setdefault("server", self.server)
         if self.add_timestamp:
-            data.setdefault('date', datetime.datetime.utcnow().isoformat())
+            data.setdefault("date", datetime.datetime.utcnow().isoformat())
         if self.namespace:
-            data.setdefault('namespace', self.namespace)
+            data.setdefault("namespace", self.namespace)
         if self.request:
-            data.setdefault('request', self.request)
+            data.setdefault("request", self.request)
         self.stats.append(data)
 
     def send_stats(self):
         tags = [
-            ('testrun', self.request),
-            ('testrun.start', self.testrun['start']),
-            ('testrun.timestamp', self.testrun['timestamp']),
-            ('test', self.namespace),
+            ("testrun", self.request),
+            ("testrun.start", self.testrun["start"]),
+            ("testrun.timestamp", self.testrun["timestamp"]),
+            ("test", self.namespace),
         ]
         for key, value in self.tags_before.items():
-            tags.append((key + '.before', value))
+            tags.append((key + ".before", value))
             try:
                 delta = self.tags_after[key] - value
-                tags.append((key + '.delta', delta))
+                tags.append((key + ".delta", delta))
             except Exception:
                 pass
         for key, value in self.tags_after.items():
-            tags.append((key + '.after', value))
-        self.collect({
-            'message': "Collected tags",
-            'tags': tags,
-        })
+            tags.append((key + ".after", value))
+        self.collect(
+            {
+                "message": "Collected tags",
+                "tags": tags,
+            }
+        )
 
         response = requests.post(
             self.url,
-            headers={
-                'X-appenlight-api-key': self.api_key},
+            headers={"X-appenlight-api-key": self.api_key},
             json=self.stats,
         )
 
@@ -1403,7 +1357,7 b' class AppenlightClient(object):'
             pprint.pprint(self.stats)
             print(response.headers)
             print(response.text)
-            raise Exception('Sending to appenlight failed')
+            raise Exception("Sending to appenlight failed")
 
 
 @pytest.fixture()
@@ -1454,9 +1408,8 b' class SettingsUtility(object):'
         self.repo_rhodecode_ui_ids = []
         self.repo_rhodecode_setting_ids = []
 
-    def create_repo_rhodecode_ui(
-            self, repo, section, value, key=None, active=True, cleanup=True):
-        key = key or sha1_safe(f'{section}{value}{repo.repo_id}')
+    def create_repo_rhodecode_ui(self, repo, section, value, key=None, active=True, cleanup=True):
+        key = key or sha1_safe(f"{section}{value}{repo.repo_id}")
 
         setting = RepoRhodeCodeUi()
         setting.repository_id = repo.repo_id
@@ -1471,9 +1424,8 b' class SettingsUtility(object):'
             self.repo_rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
-    def create_rhodecode_ui(
-            self, section, value, key=None, active=True, cleanup=True):
-        key = key or sha1_safe(f'{section}{value}')
+    def create_rhodecode_ui(self, section, value, key=None, active=True, cleanup=True):
+        key = key or sha1_safe(f"{section}{value}")
 
         setting = RhodeCodeUi()
         setting.ui_section = section
@@ -1487,10 +1439,8 b' class SettingsUtility(object):'
             self.rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
-    def create_repo_rhodecode_setting(
-            self, repo, name, value, type_, cleanup=True):
-        setting = RepoRhodeCodeSetting(
-            repo.repo_id, key=name, val=value, type=type_)
+    def create_repo_rhodecode_setting(self, repo, name, value, type_, cleanup=True):
+        setting = RepoRhodeCodeSetting(repo.repo_id, key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
@@ -1530,13 +1480,12 b' class SettingsUtility(object):'
 
 @pytest.fixture()
 def no_notifications(request):
-    notification_patcher = mock.patch(
-        'rhodecode.model.notification.NotificationModel.create')
+    notification_patcher = mock.patch("rhodecode.model.notification.NotificationModel.create")
     notification_patcher.start()
     request.addfinalizer(notification_patcher.stop)
 
 
[e-mail](scope='session')
[e-mail](scope="session")
 def repeat(request):
     """
     The number of repetitions is based on this fixture.
@@ -1544,7 +1493,7 b' def repeat(request):'
     Slower calls may divide it by 10 or 100. It is chosen in a way so that the
     tests are not too slow in our default test suite.
     """
-    return request.config.getoption('--repeat')
+    return request.config.getoption("--repeat")
 
 
 @pytest.fixture()
@@ -1562,42 +1511,17 b' def context_stub():'
 
 
 @pytest.fixture()
-def request_stub():
-    """
-    Stub request object.
-    """
-    from rhodecode.lib.base import bootstrap_request
-    request = bootstrap_request(scheme='https')
-    return request
-
-
[e-mail]()
-def config_stub(request, request_stub):
-    """
-    Set up pyramid.testing and return the Configurator.
-    """
-    from rhodecode.lib.base import bootstrap_config
-    config = bootstrap_config(request=request_stub)
-
-    @request.addfinalizer
-    def cleanup():
-        pyramid.testing.tearDown()
-
-    return config
-
-
[e-mail]()
 def StubIntegrationType():
     class _StubIntegrationType(IntegrationTypeBase):
-        """ Test integration type class """
+        """Test integration type class"""
 
-        key = 'test'
-        display_name = 'Test integration type'
-        description = 'A test integration type for testing'
+        key = "test"
+        display_name = "Test integration type"
+        description = "A test integration type for testing"
 
         @classmethod
         def icon(cls):
-            return 'test_icon_html_image'
+            return "test_icon_html_image"
 
         def __init__(self, settings):
             super(_StubIntegrationType, self).__init__(settings)
@@ -1611,15 +1535,15 b' def StubIntegrationType():'
                 test_string_field = colander.SchemaNode(
                     colander.String(),
                     missing=colander.required,
-                    title='test string field',
+                    title="test string field",
                 )
                 test_int_field = colander.SchemaNode(
                     colander.Int(),
-                    title='some integer setting',
+                    title="some integer setting",
                 )
+
             return SettingsSchema()
 
-
     integration_type_registry.register_integration_type(_StubIntegrationType)
     return _StubIntegrationType
 
@@ -1627,18 +1551,22 b' def StubIntegrationType():'
 @pytest.fixture()
 def stub_integration_settings():
     return {
-        'test_string_field': 'some data',
-        'test_int_field': 100,
+        "test_string_field": "some data",
+        "test_int_field": 100,
     }
 
 
 @pytest.fixture()
-def repo_integration_stub(request, repo_stub, StubIntegrationType,
-        stub_integration_settings):
+def repo_integration_stub(request, repo_stub, StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
-        StubIntegrationType, settings=stub_integration_settings, enabled=True,
-        name='test repo integration',
-        repo=repo_stub, repo_group=None, child_repos_only=None)
+        StubIntegrationType,
+        settings=stub_integration_settings,
+        enabled=True,
+        name="test repo integration",
+        repo=repo_stub,
+        repo_group=None,
+        child_repos_only=None,
+    )
 
     @request.addfinalizer
     def cleanup():
@@ -1648,12 +1576,16 b' def repo_integration_stub(request, repo_'
 
 
 @pytest.fixture()
-def repogroup_integration_stub(request, test_repo_group, StubIntegrationType,
-    stub_integration_settings):
+def repogroup_integration_stub(request, test_repo_group, StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
-        StubIntegrationType, settings=stub_integration_settings, enabled=True,
-        name='test repogroup integration',
-        repo=None, repo_group=test_repo_group, child_repos_only=True)
+        StubIntegrationType,
+        settings=stub_integration_settings,
+        enabled=True,
+        name="test repogroup integration",
+        repo=None,
+        repo_group=test_repo_group,
+        child_repos_only=True,
+    )
 
     @request.addfinalizer
     def cleanup():
@@ -1663,12 +1595,16 b' def repogroup_integration_stub(request, '
 
 
 @pytest.fixture()
-def repogroup_recursive_integration_stub(request, test_repo_group,
-    StubIntegrationType, stub_integration_settings):
+def repogroup_recursive_integration_stub(request, test_repo_group, StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
-        StubIntegrationType, settings=stub_integration_settings, enabled=True,
-        name='test recursive repogroup integration',
-        repo=None, repo_group=test_repo_group, child_repos_only=False)
+        StubIntegrationType,
+        settings=stub_integration_settings,
+        enabled=True,
+        name="test recursive repogroup integration",
+        repo=None,
+        repo_group=test_repo_group,
+        child_repos_only=False,
+    )
 
     @request.addfinalizer
     def cleanup():
@@ -1678,12 +1614,16 b' def repogroup_recursive_integration_stub'
 
 
 @pytest.fixture()
-def global_integration_stub(request, StubIntegrationType,
-    stub_integration_settings):
+def global_integration_stub(request, StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
-        StubIntegrationType, settings=stub_integration_settings, enabled=True,
-        name='test global integration',
-        repo=None, repo_group=None, child_repos_only=None)
+        StubIntegrationType,
+        settings=stub_integration_settings,
+        enabled=True,
+        name="test global integration",
+        repo=None,
+        repo_group=None,
+        child_repos_only=None,
+    )
 
     @request.addfinalizer
     def cleanup():
@@ -1693,12 +1633,16 b' def global_integration_stub(request, Stu'
 
 
 @pytest.fixture()
-def root_repos_integration_stub(request, StubIntegrationType,
-    stub_integration_settings):
+def root_repos_integration_stub(request, StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
-        StubIntegrationType, settings=stub_integration_settings, enabled=True,
-        name='test global integration',
-        repo=None, repo_group=None, child_repos_only=True)
+        StubIntegrationType,
+        settings=stub_integration_settings,
+        enabled=True,
+        name="test global integration",
+        repo=None,
+        repo_group=None,
+        child_repos_only=True,
+    )
 
     @request.addfinalizer
     def cleanup():
@@ -1710,8 +1654,8 b' def root_repos_integration_stub(request,'
 @pytest.fixture()
 def local_dt_to_utc():
     def _factory(dt):
-        return dt.replace(tzinfo=dateutil.tz.tzlocal()).astimezone(
-            dateutil.tz.tzutc()).replace(tzinfo=None)
+        return dt.replace(tzinfo=dateutil.tz.tzlocal()).astimezone(dateutil.tz.tzutc()).replace(tzinfo=None)
+
     return _factory
 
 
@@ -1724,7 +1668,7 b' def disable_anonymous_user(request, base'
         set_anonymous_access(True)
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 def rc_fixture(request):
     return Fixture()
 
@@ -1734,9 +1678,9 b' def repo_groups(request):'
     fixture = Fixture()
 
     session = Session()
-    zombie_group = fixture.create_repo_group('zombie')
-    parent_group = fixture.create_repo_group('parent')
-    child_group = fixture.create_repo_group('parent/child')
+    zombie_group = fixture.create_repo_group("zombie")
+    parent_group = fixture.create_repo_group("parent")
+    child_group = fixture.create_repo_group("parent/child")
     groups_in_db = session.query(RepoGroup).all()
     assert len(groups_in_db) == 3
     assert child_group.group_parent_id == parent_group.group_id
@@ -1748,3 +1692,4 b' def repo_groups(request):'
         fixture.destroy_repo_group(parent_group)
 
     return zombie_group, parent_group, child_group
+

rhodecode/tests/fixtures/rc_fixture.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -37,17 +36,16 b' from rhodecode.model.user_group import U'
 from rhodecode.model.gist import GistModel
 from rhodecode.model.auth_token import AuthTokenModel
 from rhodecode.model.scm import ScmModel
-from rhodecode.authentication.plugins.auth_rhodecode import \
-    RhodeCodeAuthPlugin
+from rhodecode.authentication.plugins.auth_rhodecode import RhodeCodeAuthPlugin
 
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 
 dn = os.path.dirname
-FIXTURES = os.path.join(dn(dn(os.path.abspath(__file__))), 'tests', 'fixtures')
+FIXTURES = os.path.join(dn(os.path.abspath(__file__)), "diff_fixtures")
 
 
 def error_function(*args, **kwargs):
-    raise Exception('Total Crash !')
+    raise Exception("Total Crash !")
 
 
 class TestINI(object):
@@ -59,8 +57,7 b' class TestINI(object):'
             print('paster server %s' % new_test_ini)
     """
 
-    def __init__(self, ini_file_path, ini_params, new_file_prefix='DEFAULT',
-                 destroy=True, dir=None):
+    def __init__(self, ini_file_path, ini_params, new_file_prefix="DEFAULT", destroy=True, dir=None):
         self.ini_file_path = ini_file_path
         self.ini_params = ini_params
         self.new_path = None
@@ -85,9 +82,8 b' class TestINI(object):'
                 parser[section][key] = str(val)
 
         with tempfile.NamedTemporaryFile(
-                mode='w',
-                prefix=self.new_path_prefix, suffix='.ini', dir=self._dir,
-                delete=False) as new_ini_file:
+            mode="w", prefix=self.new_path_prefix, suffix=".ini", dir=self._dir, delete=False
+        ) as new_ini_file:
             parser.write(new_ini_file)
             self.new_path = new_ini_file.name
 
@@ -99,7 +95,6 b' class TestINI(object):'
 
 
 class Fixture(object):
-
     def anon_access(self, status):
         """
         Context process for disabling anonymous access. use like:
@@ -139,22 +134,19 b' class Fixture(object):'
 
         class context(object):
             def _get_plugin(self):
-                plugin_id = 'egg:rhodecode-enterprise-ce#{}'.format(RhodeCodeAuthPlugin.uid)
+                plugin_id = "egg:rhodecode-enterprise-ce#{}".format(RhodeCodeAuthPlugin.uid)
                 plugin = RhodeCodeAuthPlugin(plugin_id)
                 return plugin
 
             def __enter__(self):
-
                 plugin = self._get_plugin()
-                plugin.create_or_update_setting('auth_restriction', auth_restriction)
+                plugin.create_or_update_setting("auth_restriction", auth_restriction)
                 Session().commit()
                 SettingsModel().invalidate_settings_cache(hard=True)
 
             def __exit__(self, exc_type, exc_val, exc_tb):
-
                 plugin = self._get_plugin()
-                plugin.create_or_update_setting(
-                    'auth_restriction', RhodeCodeAuthPlugin.AUTH_RESTRICTION_NONE)
+                plugin.create_or_update_setting("auth_restriction", RhodeCodeAuthPlugin.AUTH_RESTRICTION_NONE)
                 Session().commit()
                 SettingsModel().invalidate_settings_cache(hard=True)
 
@@ -173,62 +165,61 b' class Fixture(object):'
 
         class context(object):
             def _get_plugin(self):
-                plugin_id = 'egg:rhodecode-enterprise-ce#{}'.format(RhodeCodeAuthPlugin.uid)
+                plugin_id = "egg:rhodecode-enterprise-ce#{}".format(RhodeCodeAuthPlugin.uid)
                 plugin = RhodeCodeAuthPlugin(plugin_id)
                 return plugin
 
             def __enter__(self):
                 plugin = self._get_plugin()
-                plugin.create_or_update_setting('scope_restriction', scope_restriction)
+                plugin.create_or_update_setting("scope_restriction", scope_restriction)
                 Session().commit()
                 SettingsModel().invalidate_settings_cache(hard=True)
 
             def __exit__(self, exc_type, exc_val, exc_tb):
                 plugin = self._get_plugin()
-                plugin.create_or_update_setting(
-                    'scope_restriction', RhodeCodeAuthPlugin.AUTH_RESTRICTION_SCOPE_ALL)
+                plugin.create_or_update_setting("scope_restriction", RhodeCodeAuthPlugin.AUTH_RESTRICTION_SCOPE_ALL)
                 Session().commit()
                 SettingsModel().invalidate_settings_cache(hard=True)
 
         return context()
 
     def _get_repo_create_params(self, **custom):
-        repo_type = custom.get('repo_type') or 'hg'
+        repo_type = custom.get("repo_type") or "hg"
 
         default_landing_ref, landing_ref_lbl = ScmModel.backend_landing_ref(repo_type)
 
         defs = {
-            'repo_name': None,
-            'repo_type': repo_type,
-            'clone_uri': '',
-            'push_uri': '',
-            'repo_group': '-1',
-            'repo_description': 'DESC',
-            'repo_private': False,
-            'repo_landing_commit_ref': default_landing_ref,
-            'repo_copy_permissions': False,
-            'repo_state': Repository.STATE_CREATED,
+            "repo_name": None,
+            "repo_type": repo_type,
+            "clone_uri": "",
+            "push_uri": "",
+            "repo_group": "-1",
+            "repo_description": "DESC",
+            "repo_private": False,
+            "repo_landing_commit_ref": default_landing_ref,
+            "repo_copy_permissions": False,
+            "repo_state": Repository.STATE_CREATED,
         }
         defs.update(custom)
-        if 'repo_name_full' not in custom:
-            defs.update({'repo_name_full': defs['repo_name']})
+        if "repo_name_full" not in custom:
+            defs.update({"repo_name_full": defs["repo_name"]})
 
         # fix the repo name if passed as repo_name_full
-        if defs['repo_name']:
-            defs['repo_name'] = defs['repo_name'].split('/')[-1]
+        if defs["repo_name"]:
+            defs["repo_name"] = defs["repo_name"].split("/")[-1]
 
         return defs
 
     def _get_group_create_params(self, **custom):
         defs = {
-            'group_name': None,
-            'group_description': 'DESC',
-            'perm_updates': [],
-            'perm_additions': [],
-            'perm_deletions': [],
-            'group_parent_id': -1,
-            'enable_locking': False,
-            'recursive': False,
+            "group_name": None,
+            "group_description": "DESC",
+            "perm_updates": [],
+            "perm_additions": [],
+            "perm_deletions": [],
+            "group_parent_id": -1,
+            "enable_locking": False,
+            "recursive": False,
         }
         defs.update(custom)
 
@@ -236,16 +227,16 b' class Fixture(object):'
 
     def _get_user_create_params(self, name, **custom):
         defs = {
-            'username': name,
-            'password': 'qweqwe',
-            'email': '[e-mail]' % name,
-            'firstname': 'TestUser',
-            'lastname': 'Test',
-            'description': 'test description',
-            'active': True,
-            'admin': False,
-            'extern_type': 'rhodecode',
-            'extern_name': None,
+            "username": name,
+            "password": "qweqwe",
+            "email": "[e-mail]" % name,
+            "firstname": "TestUser",
+            "lastname": "Test",
+            "description": "test description",
+            "active": True,
+            "admin": False,
+            "extern_type": "rhodecode",
+            "extern_name": None,
         }
         defs.update(custom)
 
@@ -253,30 +244,30 b' class Fixture(object):'
 
     def _get_user_group_create_params(self, name, **custom):
         defs = {
-            'users_group_name': name,
-            'user_group_description': 'DESC',
-            'users_group_active': True,
-            'user_group_data': {},
+            "users_group_name": name,
+            "user_group_description": "DESC",
+            "users_group_active": True,
+            "user_group_data": {},
         }
         defs.update(custom)
 
         return defs
 
     def create_repo(self, name, **kwargs):
-        repo_group = kwargs.get('repo_group')
+        repo_group = kwargs.get("repo_group")
         if isinstance(repo_group, RepoGroup):
-            kwargs['repo_group'] = repo_group.group_id
+            kwargs["repo_group"] = repo_group.group_id
             name = name.split(Repository.NAME_SEP)[-1]
             name = Repository.NAME_SEP.join((repo_group.group_name, name))
 
-        if 'skip_if_exists' in kwargs:
-            del kwargs['skip_if_exists']
+        if "skip_if_exists" in kwargs:
+            del kwargs["skip_if_exists"]
             r = Repository.get_by_repo_name(name)
             if r:
                 return r
 
         form_data = self._get_repo_create_params(repo_name=name, **kwargs)
-        cur_user = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)
+        cur_user = kwargs.get("cur_user", TEST_USER_ADMIN_LOGIN)
         RepoModel().create(form_data, cur_user)
         Session().commit()
         repo = Repository.get_by_repo_name(name)
@@ -287,17 +278,15 b' class Fixture(object):'
         repo_to_fork = Repository.get_by_repo_name(repo_to_fork)
 
         form_data = self._get_repo_create_params(
-            repo_name=fork_name,
-            fork_parent_id=repo_to_fork.repo_id,
-            repo_type=repo_to_fork.repo_type,
-            **kwargs)
+            repo_name=fork_name, fork_parent_id=repo_to_fork.repo_id, repo_type=repo_to_fork.repo_type, **kwargs
+        )
 
         # TODO: fix it !!
-        form_data['description'] = form_data['repo_description']
-        form_data['private'] = form_data['repo_private']
-        form_data['landing_rev'] = form_data['repo_landing_commit_ref']
+        form_data["description"] = form_data["repo_description"]
+        form_data["private"] = form_data["repo_private"]
+        form_data["landing_rev"] = form_data["repo_landing_commit_ref"]
 
-        owner = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)
+        owner = kwargs.get("cur_user", TEST_USER_ADMIN_LOGIN)
         RepoModel().create_fork(form_data, cur_user=owner)
         Session().commit()
         r = Repository.get_by_repo_name(fork_name)
@@ -305,7 +294,7 b' class Fixture(object):'
         return r
 
     def destroy_repo(self, repo_name, **kwargs):
-        RepoModel().delete(repo_name, pull_requests='delete', artifacts='delete', **kwargs)
+        RepoModel().delete(repo_name, pull_requests="delete", artifacts="delete", **kwargs)
         Session().commit()
 
     def destroy_repo_on_filesystem(self, repo_name):
@@ -314,17 +303,16 b' class Fixture(object):'
             shutil.rmtree(rm_path)
 
     def create_repo_group(self, name, **kwargs):
-        if 'skip_if_exists' in kwargs:
-            del kwargs['skip_if_exists']
+        if "skip_if_exists" in kwargs:
+            del kwargs["skip_if_exists"]
             gr = RepoGroup.get_by_group_name(group_name=name)
             if gr:
                 return gr
         form_data = self._get_group_create_params(group_name=name, **kwargs)
-        owner = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)
+        owner = kwargs.get("cur_user", TEST_USER_ADMIN_LOGIN)
         gr = RepoGroupModel().create(
-            group_name=form_data['group_name'],
-            group_description=form_data['group_name'],
-            owner=owner)
+            group_name=form_data["group_name"], group_description=form_data["group_name"], owner=owner
+        )
         Session().commit()
         gr = RepoGroup.get_by_group_name(gr.group_name)
         return gr
@@ -334,8 +322,8 b' class Fixture(object):'
         Session().commit()
 
     def create_user(self, name, **kwargs):
-        if 'skip_if_exists' in kwargs:
-            del kwargs['skip_if_exists']
+        if "skip_if_exists" in kwargs:
+            del kwargs["skip_if_exists"]
             user = User.get_by_username(name)
             if user:
                 return user
@@ -343,8 +331,7 b' class Fixture(object):'
         user = UserModel().create(form_data)
 
         # create token for user
-        AuthTokenModel().create(
-                user=user, description=u'TEST_USER_TOKEN')
+        AuthTokenModel().create(user=user, description="TEST_USER_TOKEN")
 
         Session().commit()
         user = User.get_by_username(user.username)
@@ -368,22 +355,24 b' class Fixture(object):'
                 Session().commit()
 
     def create_user_group(self, name, **kwargs):
-        if 'skip_if_exists' in kwargs:
-            del kwargs['skip_if_exists']
+        if "skip_if_exists" in kwargs:
+            del kwargs["skip_if_exists"]
             gr = UserGroup.get_by_group_name(group_name=name)
             if gr:
                 return gr
         # map active flag to the real attribute. For API consistency of fixtures
-        if 'active' in kwargs:
-            kwargs['users_group_active'] = kwargs['active']
-            del kwargs['active']
+        if "active" in kwargs:
+            kwargs["users_group_active"] = kwargs["active"]
+            del kwargs["active"]
         form_data = self._get_user_group_create_params(name, **kwargs)
-        owner = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)
+        owner = kwargs.get("cur_user", TEST_USER_ADMIN_LOGIN)
         user_group = UserGroupModel().create(
-            name=form_data['users_group_name'],
-            description=form_data['user_group_description'],
-            owner=owner, active=form_data['users_group_active'],
-            group_data=form_data['user_group_data'])
+            name=form_data["users_group_name"],
+            description=form_data["user_group_description"],
+            owner=owner,
+            active=form_data["users_group_active"],
+            group_data=form_data["user_group_data"],
+        )
         Session().commit()
         user_group = UserGroup.get_by_group_name(user_group.users_group_name)
         return user_group
@@ -394,18 +383,23 b' class Fixture(object):'
 
     def create_gist(self, **kwargs):
         form_data = {
-            'description': 'new-gist',
-            'owner': TEST_USER_ADMIN_LOGIN,
-            'gist_type': GistModel.cls.GIST_PUBLIC,
-            'lifetime': -1,
-            'acl_level': Gist.ACL_LEVEL_PUBLIC,
-            'gist_mapping': {b'filename1.txt': {'content': b'hello world'},}
+            "description": "new-gist",
+            "owner": TEST_USER_ADMIN_LOGIN,
+            "gist_type": GistModel.cls.GIST_PUBLIC,
+            "lifetime": -1,
+            "acl_level": Gist.ACL_LEVEL_PUBLIC,
+            "gist_mapping": {
+                b"filename1.txt": {"content": b"hello world"},
+            },
         }
         form_data.update(kwargs)
         gist = GistModel().create(
-            description=form_data['description'], owner=form_data['owner'],
-            gist_mapping=form_data['gist_mapping'], gist_type=form_data['gist_type'],
-            lifetime=form_data['lifetime'], gist_acl_level=form_data['acl_level']
+            description=form_data["description"],
+            owner=form_data["owner"],
+            gist_mapping=form_data["gist_mapping"],
+            gist_type=form_data["gist_type"],
+            lifetime=form_data["lifetime"],
+            gist_acl_level=form_data["acl_level"],
         )
         Session().commit()
         return gist
@@ -420,7 +414,7 b' class Fixture(object):'
         Session().commit()
 
     def load_resource(self, resource_name, strip=False):
-        with open(os.path.join(FIXTURES, resource_name), 'rb') as f:
+        with open(os.path.join(FIXTURES, resource_name), "rb") as f:
             source = f.read()
             if strip:
                 source = source.strip()

rhodecode/tests/functional/test_delegated_admin.py

@@ -21,7 +21,7 b''
 import pytest
 
 from rhodecode.tests import TestController
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests.routes import route_path
 
 

rhodecode/tests/integrations/test_integration.py

@@ -20,7 +20,7 b' import time'
 import pytest
 
 from rhodecode import events
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.model.db import Session, Integration
 from rhodecode.model.integration import IntegrationModel
 

rhodecode/tests/lib/middleware/test_simplehg.py

@@ -123,10 +123,14 b' def test_get_config(user_util, baseapp, '
         ('web', 'allow_push', '*'),
         ('web', 'allow_archive', 'gz zip bz2'),
         ('web', 'baseurl', '/'),
+
+        # largefiles data...
         ('vcs_git_lfs', 'store_location', hg_config_org.get('vcs_git_lfs', 'store_location')),
+        ('largefiles', 'usercache', hg_config_org.get('largefiles', 'usercache')),
+
         ('vcs_svn_branch', '9aac1a38c3b8a0cdc4ae0f960a5f83332bc4fa5e', '/branches/*'),
         ('vcs_svn_branch', 'c7e6a611c87da06529fd0dd733308481d67c71a8', '/trunk'),
-        ('largefiles', 'usercache', hg_config_org.get('largefiles', 'usercache')),
+
         ('hooks', 'preoutgoing.pre_pull', 'python:vcsserver.hooks.pre_pull'),
         ('hooks', 'prechangegroup.pre_push', 'python:vcsserver.hooks.pre_push'),
         ('hooks', 'outgoing.pull_logger', 'python:vcsserver.hooks.log_pull_action'),

rhodecode/tests/lib/middleware/test_simplevcs.py

@@ -22,7 +22,8 b' import pytest'
 
 from rhodecode.lib.str_utils import base64_to_str
 from rhodecode.lib.utils2 import AttributeDict
-from rhodecode.tests.utils import CustomTestApp
+from rhodecode.tests.fixtures.fixture_pyramid import ini_config
+from rhodecode.tests.utils import CustomTestApp, AuthPluginManager
 
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.middleware import simplevcs
@@ -34,6 +35,57 b' from rhodecode.tests import ('
     HG_REPO, TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
 from rhodecode.tests.lib.middleware import mock_scm_app
 
+from rhodecode.model.db import Permission, User
+from rhodecode.model.meta import Session
+from rhodecode.model.user import UserModel
+
+
[e-mail]()
+def enable_auth_plugins(request, app):
+    """
+    Return a factory object that when called, allows to control which
+    authentication plugins are enabled.
+    """
+
+    enabler = AuthPluginManager()
+    request.addfinalizer(enabler.cleanup)
+
+    return enabler
+
+
[e-mail]()
+def test_user_factory(request, baseapp):
+
+    def user_factory(username='test_user', password='qweqwe', first_name='John', last_name='Testing', **kwargs):
+        usr = UserModel().create_or_update(
+            username=username,
+            password=password,
+            email=f'{username}@rhodecode.org',
+            firstname=first_name, lastname=last_name)
+        Session().commit()
+
+        for k, v in kwargs.items():
+            setattr(usr, k, v)
+            Session().add(usr)
+
+        new_usr = User.get_by_username(username)
+        new_usr_id = new_usr.user_id
+        assert new_usr == usr
+
+        @request.addfinalizer
+        def cleanup():
+            if User.get(new_usr_id) is None:
+                return
+
+            perm = Permission.query().all()
+            for p in perm:
+                UserModel().revoke_perm(usr, p)
+
+            UserModel().delete(new_usr_id)
+            Session().commit()
+        return usr
+
+    return user_factory
 
 class StubVCSController(simplevcs.SimpleVCS):
 
@@ -107,8 +159,7 b' def _remove_default_user_from_query_cach'
     Session().expire(user)
 
 
-def test_handles_exceptions_during_permissions_checks(
-        vcscontroller, disable_anonymous_user, enable_auth_plugins, test_user_factory):
+def test_handles_exceptions_during_permissions_checks(vcscontroller, disable_anonymous_user, enable_auth_plugins, test_user_factory):
 
     test_password = 'qweqwe'
     test_user = test_user_factory(password=test_password, extern_type='headers', extern_name='headers')
@@ -373,29 +424,30 b' class TestShadowRepoExposure(object):'
                 controller.vcs_repo_name)
 
 
[e-mail]('baseapp')
 class TestGenerateVcsResponse(object):
 
-    def test_ensures_that_start_response_is_called_early_enough(self):
-        self.call_controller_with_response_body(iter(['a', 'b']))
+    def test_ensures_that_start_response_is_called_early_enough(self, baseapp):
+        app_ini_config = baseapp.config.registry.settings['__file__']
+        self.call_controller_with_response_body(app_ini_config, iter(['a', 'b']))
         assert self.start_response.called
 
-    def test_invalidates_cache_after_body_is_consumed(self):
-        result = self.call_controller_with_response_body(iter(['a', 'b']))
+    def test_invalidates_cache_after_body_is_consumed(self, baseapp):
+        app_ini_config = baseapp.config.registry.settings['__file__']
+        result = self.call_controller_with_response_body(app_ini_config, iter(['a', 'b']))
         assert not self.was_cache_invalidated()
         # Consume the result
         list(result)
         assert self.was_cache_invalidated()
 
-    def test_raises_unknown_exceptions(self):
-        result = self.call_controller_with_response_body(
-            self.raise_result_iter(vcs_kind='unknown'))
+    def test_raises_unknown_exceptions(self, baseapp):
+        app_ini_config = baseapp.config.registry.settings['__file__']
+        result = self.call_controller_with_response_body(app_ini_config, self.raise_result_iter(vcs_kind='unknown'))
         with pytest.raises(Exception):
             list(result)
 
-    def call_controller_with_response_body(self, response_body):
+    def call_controller_with_response_body(self, ini_config, response_body):
+
         settings = {
-            'base_path': 'fake_base_path',
             'vcs.hooks.protocol.v2': 'celery',
             'vcs.hooks.direct_calls': False,
         }
@@ -407,7 +459,7 b' class TestGenerateVcsResponse(object):'
         result = controller._generate_vcs_response(
             environ={}, start_response=self.start_response,
             repo_path='fake_repo_path',
-            extras={}, action='push')
+            extras={'config': ini_config}, action='push')
         self.controller = controller
         return result
 

rhodecode/tests/lib/middleware/utils/test_scm_app_http.py

@@ -19,6 +19,7 b''
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
+import tempfile
 
 from rhodecode.tests.utils import CustomTestApp
 from rhodecode.lib.middleware.utils import scm_app_http, scm_app
@@ -41,10 +42,13 b' def vcsserver_http_echo_app(request, vcs'
     """
     A running VCSServer with the EchoApp activated via HTTP.
     """
-    vcsserver = vcsserver_factory(
+    store_dir = tempfile.gettempdir()
+
+    vcsserver_instance = vcsserver_factory(
         request=request,
+        store_dir=store_dir,
         overrides=[{'app:main': {'dev.use_echo_app': 'true'}}])
-    return vcsserver
+    return vcsserver_instance
 
 
 @pytest.fixture(scope='session')

rhodecode/tests/lib/test_auth.py

@@ -1,5 +1,4 b''
-
-# Copyright (C) 2010-2023 RhodeCode GmbH
+# Copyright (C) 2010-2024 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

rhodecode/tests/lib/test_diffs.py

@@ -30,7 +30,7 b' from rhodecode.lib.diffs import ('
 
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.lib.vcs.backends.git import GitCommit
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.tests import no_newline_id_generator
 from rhodecode.lib.vcs.backends.git.repository import GitDiff
 from rhodecode.lib.vcs.backends.hg.repository import MercurialDiff

rhodecode/tests/lib/test_hooks_daemon.py

@@ -1,5 +1,4 b''
-
-# Copyright (C) 2010-2023 RhodeCode GmbH
+# Copyright (C) 2010-2024 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
@@ -18,305 +17,71 b''
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
-import io
 
 import mock
-import msgpack
 import pytest
 import tempfile
 
-from rhodecode.lib.hook_daemon import http_hooks_deamon
 from rhodecode.lib.hook_daemon import celery_hooks_deamon
-from rhodecode.lib.hook_daemon import hook_module
+from rhodecode.lib.hook_daemon import utils as hooks_utils
 from rhodecode.lib.hook_daemon import base as hook_base
-from rhodecode.lib.str_utils import safe_bytes
+
 from rhodecode.tests.utils import assert_message_in_log
-from rhodecode.lib.ext_json import json
-
-test_proto = http_hooks_deamon.HooksHttpHandler.MSGPACK_HOOKS_PROTO
 
 
 class TestHooks(object):
     def test_hooks_can_be_used_as_a_context_processor(self):
-        hooks = hook_module.Hooks()
+        hooks = hook_base.Hooks()
         with hooks as return_value:
             pass
         assert hooks == return_value
 
-
-class TestHooksHttpHandler(object):
-    def test_read_request_parses_method_name_and_arguments(self):
-        data = {
-            'method': 'test',
-            'extras': {
-                'param1': 1,
-                'param2': 'a'
-            }
-        }
-        request = self._generate_post_request(data)
-        hooks_patcher = mock.patch.object(
-            hook_module.Hooks, data['method'], create=True, return_value=1)
-
-        with hooks_patcher as hooks_mock:
-            handler = http_hooks_deamon.HooksHttpHandler
-            handler.DEFAULT_HOOKS_PROTO = test_proto
-            handler.wbufsize = 10240
-            MockServer(handler, request)
-
-        hooks_mock.assert_called_once_with(data['extras'])
-
-    def test_hooks_serialized_result_is_returned(self):
-        request = self._generate_post_request({})
-        rpc_method = 'test'
-        hook_result = {
-            'first': 'one',
-            'second': 2
-        }
-        extras = {}
-
-        # patching our _read to return test method and proto used
-        read_patcher = mock.patch.object(
-            http_hooks_deamon.HooksHttpHandler, '_read_request',
-            return_value=(test_proto, rpc_method, extras))
-
-        # patch Hooks instance to return hook_result data on 'test' call
-        hooks_patcher = mock.patch.object(
-            hook_module.Hooks, rpc_method, create=True,
-            return_value=hook_result)
-
-        with read_patcher, hooks_patcher:
-            handler = http_hooks_deamon.HooksHttpHandler
-            handler.DEFAULT_HOOKS_PROTO = test_proto
-            handler.wbufsize = 10240
-            server = MockServer(handler, request)
-
-        expected_result = http_hooks_deamon.HooksHttpHandler.serialize_data(hook_result)
-
-        server.request.output_stream.seek(0)
-        assert server.request.output_stream.readlines()[-1] == expected_result
-
-    def test_exception_is_returned_in_response(self):
-        request = self._generate_post_request({})
-        rpc_method = 'test'
-
-        read_patcher = mock.patch.object(
-            http_hooks_deamon.HooksHttpHandler, '_read_request',
-            return_value=(test_proto, rpc_method, {}))
-
-        hooks_patcher = mock.patch.object(
-            hook_module.Hooks, rpc_method, create=True,
-            side_effect=Exception('Test exception'))
-
-        with read_patcher, hooks_patcher:
-            handler = http_hooks_deamon.HooksHttpHandler
-            handler.DEFAULT_HOOKS_PROTO = test_proto
-            handler.wbufsize = 10240
-            server = MockServer(handler, request)
-
-        server.request.output_stream.seek(0)
-        data = server.request.output_stream.readlines()
-        msgpack_data = b''.join(data[5:])
-        org_exc = http_hooks_deamon.HooksHttpHandler.deserialize_data(msgpack_data)
-        expected_result = {
-            'exception': 'Exception',
-            'exception_traceback': org_exc['exception_traceback'],
-            'exception_args': ['Test exception']
-        }
-        assert org_exc == expected_result
-
-    def test_log_message_writes_to_debug_log(self, caplog):
-        ip_port = ('0.0.0.0', 8888)
-        handler = http_hooks_deamon.HooksHttpHandler(MockRequest('POST /'), ip_port, mock.Mock())
-        fake_date = '1/Nov/2015 00:00:00'
-        date_patcher = mock.patch.object(
-            handler, 'log_date_time_string', return_value=fake_date)
-
-        with date_patcher, caplog.at_level(logging.DEBUG):
-            handler.log_message('Some message %d, %s', 123, 'string')
-
-        expected_message = f"HOOKS: client={ip_port} - - [{fake_date}] Some message 123, string"
-
-        assert_message_in_log(
-            caplog.records, expected_message,
-            levelno=logging.DEBUG, module='http_hooks_deamon')
-
-    def _generate_post_request(self, data, proto=test_proto):
-        if proto == http_hooks_deamon.HooksHttpHandler.MSGPACK_HOOKS_PROTO:
-            payload = msgpack.packb(data)
-        else:
-            payload = json.dumps(data)
-
-        return b'POST / HTTP/1.0\nContent-Length: %d\n\n%b' % (
-            len(payload), payload)
-
-
-class ThreadedHookCallbackDaemon(object):
-    def test_constructor_calls_prepare(self):
-        prepare_daemon_patcher = mock.patch.object(
-            http_hooks_deamon.ThreadedHookCallbackDaemon, '_prepare')
-        with prepare_daemon_patcher as prepare_daemon_mock:
-            http_hooks_deamon.ThreadedHookCallbackDaemon()
-        prepare_daemon_mock.assert_called_once_with()
-
-    def test_run_is_called_on_context_start(self):
-        patchers = mock.patch.multiple(
-            http_hooks_deamon.ThreadedHookCallbackDaemon,
-            _run=mock.DEFAULT, _prepare=mock.DEFAULT, __exit__=mock.DEFAULT)
-
-        with patchers as mocks:
-            daemon = http_hooks_deamon.ThreadedHookCallbackDaemon()
-            with daemon as daemon_context:
-                pass
-            mocks['_run'].assert_called_once_with()
-        assert daemon_context == daemon
-
-    def test_stop_is_called_on_context_exit(self):
-        patchers = mock.patch.multiple(
-            http_hooks_deamon.ThreadedHookCallbackDaemon,
-            _run=mock.DEFAULT, _prepare=mock.DEFAULT, _stop=mock.DEFAULT)
-
-        with patchers as mocks:
-            daemon = http_hooks_deamon.ThreadedHookCallbackDaemon()
-            with daemon as daemon_context:
-                assert mocks['_stop'].call_count == 0
-
-            mocks['_stop'].assert_called_once_with()
-        assert daemon_context == daemon
-
-
-class TestHttpHooksCallbackDaemon(object):
-    def test_hooks_callback_generates_new_port(self, caplog):
-        with caplog.at_level(logging.DEBUG):
-            daemon = http_hooks_deamon.HttpHooksCallbackDaemon(host='127.0.0.1', port=8881)
-        assert daemon._daemon.server_address == ('127.0.0.1', 8881)
-
-        with caplog.at_level(logging.DEBUG):
-            daemon = http_hooks_deamon.HttpHooksCallbackDaemon(host=None, port=None)
-        assert daemon._daemon.server_address[1] in range(0, 66000)
-        assert daemon._daemon.server_address[0] != '127.0.0.1'
-
-    def test_prepare_inits_daemon_variable(self, tcp_server, caplog):
-        with self._tcp_patcher(tcp_server), caplog.at_level(logging.DEBUG):
-            daemon = http_hooks_deamon.HttpHooksCallbackDaemon(host='127.0.0.1', port=8881)
-        assert daemon._daemon == tcp_server
-
-        _, port = tcp_server.server_address
-
-        msg = f"HOOKS: 127.0.0.1:{port}  Preparing HTTP callback daemon registering " \
-              f"hook object: <class 'rhodecode.lib.hook_daemon.http_hooks_deamon.HooksHttpHandler'>"
-        assert_message_in_log(
-            caplog.records, msg, levelno=logging.DEBUG, module='http_hooks_deamon')
-
-    def test_prepare_inits_hooks_uri_and_logs_it(
-            self, tcp_server, caplog):
-        with self._tcp_patcher(tcp_server), caplog.at_level(logging.DEBUG):
-            daemon = http_hooks_deamon.HttpHooksCallbackDaemon(host='127.0.0.1', port=8881)
-
-        _, port = tcp_server.server_address
-        expected_uri = '{}:{}'.format('127.0.0.1', port)
-        assert daemon.hooks_uri == expected_uri
-
-        msg = f"HOOKS: 127.0.0.1:{port}  Preparing HTTP callback daemon registering " \
-              f"hook object: <class 'rhodecode.lib.hook_daemon.http_hooks_deamon.HooksHttpHandler'>"
-
-        assert_message_in_log(
-            caplog.records, msg,
-            levelno=logging.DEBUG, module='http_hooks_deamon')
-
-    def test_run_creates_a_thread(self, tcp_server):
-        thread = mock.Mock()
-
-        with self._tcp_patcher(tcp_server):
-            daemon = http_hooks_deamon.HttpHooksCallbackDaemon()
-
-        with self._thread_patcher(thread) as thread_mock:
-            daemon._run()
-
-        thread_mock.assert_called_once_with(
-            target=tcp_server.serve_forever,
-            kwargs={'poll_interval': daemon.POLL_INTERVAL})
-        assert thread.daemon is True
-        thread.start.assert_called_once_with()
-
-    def test_run_logs(self, tcp_server, caplog):
-
-        with self._tcp_patcher(tcp_server):
-            daemon = http_hooks_deamon.HttpHooksCallbackDaemon()
-
-        with self._thread_patcher(mock.Mock()), caplog.at_level(logging.DEBUG):
-            daemon._run()
-
-        assert_message_in_log(
-            caplog.records,
-            'Running thread-based loop of callback daemon in background',
-            levelno=logging.DEBUG, module='http_hooks_deamon')
-
-    def test_stop_cleans_up_the_connection(self, tcp_server, caplog):
-        thread = mock.Mock()
-
-        with self._tcp_patcher(tcp_server):
-            daemon = http_hooks_deamon.HttpHooksCallbackDaemon()
-
-        with self._thread_patcher(thread), caplog.at_level(logging.DEBUG):
-            with daemon:
-                assert daemon._daemon == tcp_server
-                assert daemon._callback_thread == thread
-
-        assert daemon._daemon is None
-        assert daemon._callback_thread is None
-        tcp_server.shutdown.assert_called_with()
-        thread.join.assert_called_once_with()
-
-        assert_message_in_log(
-            caplog.records, 'Waiting for background thread to finish.',
-            levelno=logging.DEBUG, module='http_hooks_deamon')
-
-    def _tcp_patcher(self, tcp_server):
-        return mock.patch.object(
-            http_hooks_deamon, 'TCPServer', return_value=tcp_server)
-
-    def _thread_patcher(self, thread):
-        return mock.patch.object(
-            http_hooks_deamon.threading, 'Thread', return_value=thread)
-
-
 class TestPrepareHooksDaemon(object):
 
     @pytest.mark.parametrize('protocol', ('celery',))
-    def test_returns_celery_hooks_callback_daemon_when_celery_protocol_specified(
-            self, protocol):
+    def test_returns_celery_hooks_callback_daemon_when_celery_protocol_specified(self, protocol):
         with tempfile.NamedTemporaryFile(mode='w') as temp_file:
-            temp_file.write("[app:main]\ncelery.broker_url = redis://redis/0\n"
-                            "celery.result_backend = redis://redis/0")
+            temp_file.write(
+                "[app:main]\n"
+                "celery.broker_url = redis://redis/0\n"
+                "celery.result_backend = redis://redis/0\n"
+            )
             temp_file.flush()
             expected_extras = {'config': temp_file.name}
-            callback, extras = hook_base.prepare_callback_daemon(
-                expected_extras, protocol=protocol, host='')
+            callback, extras = hooks_utils.prepare_callback_daemon(expected_extras, protocol=protocol)
             assert isinstance(callback, celery_hooks_deamon.CeleryHooksCallbackDaemon)
 
     @pytest.mark.parametrize('protocol, expected_class', (
-        ('http', http_hooks_deamon.HttpHooksCallbackDaemon),
+        ('celery', celery_hooks_deamon.CeleryHooksCallbackDaemon),
     ))
-    def test_returns_real_hooks_callback_daemon_when_protocol_is_specified(
-            self, protocol, expected_class):
-        expected_extras = {
-            'extra1': 'value1',
-            'txn_id': 'txnid2',
-            'hooks_protocol': protocol.lower(),
-            'task_backend': '',
-            'task_queue': '',
-            'repo_store': '/var/opt/rhodecode_repo_store',
-            'repository': 'rhodecode',
-        }
-        from rhodecode import CONFIG
-        CONFIG['vcs.svn.redis_conn'] = 'redis://redis:6379/0'
-        callback, extras = hook_base.prepare_callback_daemon(
-            expected_extras.copy(), protocol=protocol, host='127.0.0.1',
-            txn_id='txnid2')
-        assert isinstance(callback, expected_class)
-        extras.pop('hooks_uri')
-        expected_extras['time'] = extras['time']
-        assert extras == expected_extras
+    def test_returns_real_hooks_callback_daemon_when_protocol_is_specified(self, protocol, expected_class):
+
+        with tempfile.NamedTemporaryFile(mode='w') as temp_file:
+            temp_file.write(
+                "[app:main]\n"
+                "celery.broker_url = redis://redis:6379/0\n"
+                "celery.result_backend = redis://redis:6379/0\n"
+            )
+            temp_file.flush()
+
+            expected_extras = {
+                'extra1': 'value1',
+                'txn_id': 'txnid2',
+                'hooks_protocol': protocol.lower(),
+                'hooks_config': {
+                    'broker_url': 'redis://redis:6379/0',
+                    'result_backend': 'redis://redis:6379/0',
+                },
+                'repo_store': '/var/opt/rhodecode_repo_store',
+                'repository': 'rhodecode',
+                'config': temp_file.name
+            }
+            from rhodecode import CONFIG
+            CONFIG['vcs.svn.redis_conn'] = 'redis://redis:6379/0'
+            callback, extras = hooks_utils.prepare_callback_daemon(expected_extras.copy(), protocol=protocol,txn_id='txnid2')
+            assert isinstance(callback, expected_class)
+            expected_extras['time'] = extras['time']
+            assert extras == expected_extras
 
     @pytest.mark.parametrize('protocol', (
         'invalid',
@@ -330,35 +95,4 b' class TestPrepareHooksDaemon(object):'
             'hooks_protocol': protocol.lower()
         }
         with pytest.raises(Exception):
-            callback, extras = hook_base.prepare_callback_daemon(
-                expected_extras.copy(),
-                protocol=protocol, host='127.0.0.1')
-
-
-class MockRequest(object):
-
-    def __init__(self, request):
-        self.request = request
-        self.input_stream = io.BytesIO(safe_bytes(self.request))
-        self.output_stream = io.BytesIO()  # make it un-closable for testing invesitagion
-        self.output_stream.close = lambda: None
-
-    def makefile(self, mode, *args, **kwargs):
-        return self.output_stream if mode == 'wb' else self.input_stream
-
-
-class MockServer(object):
-
-    def __init__(self, handler_cls, request):
-        ip_port = ('0.0.0.0', 8888)
-        self.request = MockRequest(request)
-        self.server_address = ip_port
-        self.handler = handler_cls(self.request, ip_port, self)
-
-
[e-mail]()
-def tcp_server():
-    server = mock.Mock()
-    server.server_address = ('127.0.0.1', 8881)
-    server.wbufsize = 1024
-    return server
+            callback, extras = hooks_utils.prepare_callback_daemon(expected_extras.copy(), protocol=protocol)

rhodecode/tests/lib/test_utils.py

@@ -33,7 +33,7 b' from rhodecode.model import meta'
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.settings import UiSetting, SettingsModel
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode_tools.lib.hash_utils import md5_safe
 from rhodecode.lib.ext_json import json
 
@@ -403,12 +403,9 b' class TestPrepareConfigData(object):'
 
         self._assert_repo_name_passed(model_mock, repo_name)
 
-        expected_result = [
-            ('section1', 'option1', 'value1'),
-            ('section2', 'option2', 'value2'),
-        ]
-        # We have extra config items returned, so we're ignoring two last items
-        assert result[:2] == expected_result
+        assert ('section1', 'option1', 'value1') in result
+        assert ('section2', 'option2', 'value2') in result
+        assert ('section3', 'option3', 'value3') not in result
 
     def _assert_repo_name_passed(self, model_mock, repo_name):
         assert model_mock.call_count == 1

rhodecode/tests/load/http_performance.py

@@ -25,7 +25,7 b' It works by replaying a group of commits'
 
 import argparse
 import collections
-import ConfigParser
+import configparser
 import functools
 import itertools
 import os
@@ -294,7 +294,7 b' class HgMixin(object):'
     def add_remote(self, repo, remote_url, remote_name='upstream'):
         self.remove_remote(repo, remote_name)
         os.chdir(repo)
-        hgrc = ConfigParser.RawConfigParser()
+        hgrc = configparser.RawConfigParser()
         hgrc.read('.hg/hgrc')
         hgrc.set('paths', remote_name, remote_url)
         with open('.hg/hgrc', 'w') as f:
@@ -303,7 +303,7 b' class HgMixin(object):'
     @keep_cwd
     def remove_remote(self, repo, remote_name='upstream'):
         os.chdir(repo)
-        hgrc = ConfigParser.RawConfigParser()
+        hgrc = configparser.RawConfigParser()
         hgrc.read('.hg/hgrc')
         hgrc.remove_option('paths', remote_name)
         with open('.hg/hgrc', 'w') as f:

rhodecode/tests/load/profile-mem.py

@@ -59,16 +59,6 b' def parse_options():'
     parser.add_argument(
         '--interval', '-i', type=float, default=5,
         help="Interval in secods.")
-    parser.add_argument(
-        '--appenlight', '--ae', action='store_true')
-    parser.add_argument(
-        '--appenlight-url', '--ae-url',
-        default='https://ae.rhodecode.com/api/logs',
-        help='URL of the Appenlight API endpoint, defaults to "%(default)s".')
-    parser.add_argument(
-        '--appenlight-api-key', '--ae-key',
-        help='API key to use when sending data to appenlight. This has to be '
-             'set if Appenlight is enabled.')
     return parser.parse_args()
 
 

rhodecode/tests/load/profile.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify

rhodecode/tests/load/vcs_performance.py

@@ -1,5 +1,3 b''
-
-
 # Copyright (C) 2016-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify

rhodecode/tests/models/common.py

@@ -22,7 +22,7 b' from rhodecode.model.meta import Session'
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 
 
 fixture = Fixture()

rhodecode/tests/models/test_notifications.py

@@ -19,7 +19,7 b''
 
 import pytest
 
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 
 from rhodecode.model.db import User, Notification, UserNotification
 from rhodecode.model.meta import Session

rhodecode/tests/models/test_permissions.py

@@ -29,7 +29,7 b' from rhodecode.model.repo import RepoMod'
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.user_group import UserGroupModel
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 
 
 fixture = Fixture()

rhodecode/tests/models/test_pullrequest.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -16,6 +15,7 b''
 # 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
@@ -23,8 +23,7 b' import textwrap'
 
 import rhodecode
 from rhodecode.lib.vcs.backends import get_backend
-from rhodecode.lib.vcs.backends.base import (
-    MergeResponse, MergeFailureReason, Reference)
+from rhodecode.lib.vcs.backends.base import MergeResponse, MergeFailureReason, Reference
 from rhodecode.lib.vcs.exceptions import RepositoryError
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.model.comment import CommentsModel
@@ -39,54 +38,42 b' pytestmark = ['
 ]
 
 
[e-mail]('config_stub')
[e-mail]("config_stub")
 class TestPullRequestModel(object):
-
     @pytest.fixture()
     def pull_request(self, request, backend, pr_util):
         """
         A pull request combined with multiples patches.
         """
         BackendClass = get_backend(backend.alias)
-        merge_resp = MergeResponse(
-            False, False, None, MergeFailureReason.UNKNOWN,
-            metadata={'exception': 'MockError'})
-        self.merge_patcher = mock.patch.object(
-            BackendClass, 'merge', return_value=merge_resp)
-        self.workspace_remove_patcher = mock.patch.object(
-            BackendClass, 'cleanup_merge_workspace')
+        merge_resp = MergeResponse(False, False, None, MergeFailureReason.UNKNOWN, metadata={"exception": "MockError"})
+        self.merge_patcher = mock.patch.object(BackendClass, "merge", return_value=merge_resp)
+        self.workspace_remove_patcher = mock.patch.object(BackendClass, "cleanup_merge_workspace")
 
         self.workspace_remove_mock = self.workspace_remove_patcher.start()
         self.merge_mock = self.merge_patcher.start()
-        self.comment_patcher = mock.patch(
-            'rhodecode.model.changeset_status.ChangesetStatusModel.set_status')
+        self.comment_patcher = mock.patch("rhodecode.model.changeset_status.ChangesetStatusModel.set_status")
         self.comment_patcher.start()
-        self.notification_patcher = mock.patch(
-            'rhodecode.model.notification.NotificationModel.create')
+        self.notification_patcher = mock.patch("rhodecode.model.notification.NotificationModel.create")
         self.notification_patcher.start()
-        self.helper_patcher = mock.patch(
-            'rhodecode.lib.helpers.route_path')
+        self.helper_patcher = mock.patch("rhodecode.lib.helpers.route_path")
         self.helper_patcher.start()
 
-        self.hook_patcher = mock.patch.object(PullRequestModel,
-                                              'trigger_pull_request_hook')
+        self.hook_patcher = mock.patch.object(PullRequestModel, "trigger_pull_request_hook")
         self.hook_mock = self.hook_patcher.start()
 
-        self.invalidation_patcher = mock.patch(
-            'rhodecode.model.pull_request.ScmModel.mark_for_invalidation')
+        self.invalidation_patcher = mock.patch("rhodecode.model.pull_request.ScmModel.mark_for_invalidation")
         self.invalidation_mock = self.invalidation_patcher.start()
 
-        self.pull_request = pr_util.create_pull_request(
-            mergeable=True, name_suffix=u'ąć')
+        self.pull_request = pr_util.create_pull_request(mergeable=True, name_suffix="ąć")
         self.source_commit = self.pull_request.source_ref_parts.commit_id
         self.target_commit = self.pull_request.target_ref_parts.commit_id
-        self.workspace_id = 'pr-%s' % self.pull_request.pull_request_id
+        self.workspace_id = f"pr-{self.pull_request.pull_request_id}"
         self.repo_id = self.pull_request.target_repo.repo_id
 
         @request.addfinalizer
         def cleanup_pull_request():
-            calls = [mock.call(
-                self.pull_request, self.pull_request.author, 'create')]
+            calls = [mock.call(self.pull_request, self.pull_request.author, "create")]
             self.hook_mock.assert_has_calls(calls)
 
             self.workspace_remove_patcher.stop()
@@ -114,29 +101,30 b' class TestPullRequestModel(object):'
         assert len(prs) == 1
 
     def test_count_awaiting_review(self, pull_request):
-        pr_count = PullRequestModel().count_awaiting_review(
-            pull_request.target_repo)
+        pr_count = PullRequestModel().count_awaiting_review(pull_request.target_repo)
         assert pr_count == 1
 
     def test_get_awaiting_my_review(self, pull_request):
         PullRequestModel().update_reviewers(
-            pull_request, [(pull_request.author, ['author'], False, 'reviewer', [])],
-            pull_request.author)
+            pull_request, [(pull_request.author, ["author"], False, "reviewer", [])], pull_request.author
+        )
         Session().commit()
 
         prs = PullRequestModel().get_awaiting_my_review(
-            pull_request.target_repo.repo_name, user_id=pull_request.author.user_id)
+            pull_request.target_repo.repo_name, user_id=pull_request.author.user_id
+        )
         assert isinstance(prs, list)
         assert len(prs) == 1
 
     def test_count_awaiting_my_review(self, pull_request):
         PullRequestModel().update_reviewers(
-            pull_request, [(pull_request.author, ['author'], False, 'reviewer', [])],
-            pull_request.author)
+            pull_request, [(pull_request.author, ["author"], False, "reviewer", [])], pull_request.author
+        )
         Session().commit()
 
         pr_count = PullRequestModel().count_awaiting_my_review(
-            pull_request.target_repo.repo_name, user_id=pull_request.author.user_id)
+            pull_request.target_repo.repo_name, user_id=pull_request.author.user_id
+        )
         assert pr_count == 1
 
     def test_delete_calls_cleanup_merge(self, pull_request):
@@ -144,24 +132,19 b' class TestPullRequestModel(object):'
         PullRequestModel().delete(pull_request, pull_request.author)
         Session().commit()
 
-        self.workspace_remove_mock.assert_called_once_with(
-            repo_id, self.workspace_id)
+        self.workspace_remove_mock.assert_called_once_with(repo_id, self.workspace_id)
 
     def test_close_calls_cleanup_and_hook(self, pull_request):
-        PullRequestModel().close_pull_request(
-            pull_request, pull_request.author)
+        PullRequestModel().close_pull_request(pull_request, pull_request.author)
         Session().commit()
 
         repo_id = pull_request.target_repo.repo_id
 
-        self.workspace_remove_mock.assert_called_once_with(
-            repo_id, self.workspace_id)
-        self.hook_mock.assert_called_with(
-            self.pull_request, self.pull_request.author, 'close')
+        self.workspace_remove_mock.assert_called_once_with(repo_id, self.workspace_id)
+        self.hook_mock.assert_called_with(self.pull_request, self.pull_request.author, "close")
 
     def test_merge_status(self, pull_request):
-        self.merge_mock.return_value = MergeResponse(
-            True, False, None, MergeFailureReason.NONE)
+        self.merge_mock.return_value = MergeResponse(True, False, None, MergeFailureReason.NONE)
 
         assert pull_request._last_merge_source_rev is None
         assert pull_request._last_merge_target_rev is None
@@ -169,13 +152,17 b' class TestPullRequestModel(object):'
 
         merge_response, status, msg = PullRequestModel().merge_status(pull_request)
         assert status is True
-        assert msg == 'This pull request can be automatically merged.'
+        assert msg == "This pull request can be automatically merged."
         self.merge_mock.assert_called_with(
-            self.repo_id, self.workspace_id,
+            self.repo_id,
+            self.workspace_id,
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
-            pull_request.source_ref_parts, dry_run=True,
-            use_rebase=False, close_branch=False)
+            pull_request.source_ref_parts,
+            dry_run=True,
+            use_rebase=False,
+            close_branch=False,
+        )
 
         assert pull_request._last_merge_source_rev == self.source_commit
         assert pull_request._last_merge_target_rev == self.target_commit
@@ -184,13 +171,13 b' class TestPullRequestModel(object):'
         self.merge_mock.reset_mock()
         merge_response, status, msg = PullRequestModel().merge_status(pull_request)
         assert status is True
-        assert msg == 'This pull request can be automatically merged.'
+        assert msg == "This pull request can be automatically merged."
         assert self.merge_mock.called is False
 
     def test_merge_status_known_failure(self, pull_request):
         self.merge_mock.return_value = MergeResponse(
-            False, False, None, MergeFailureReason.MERGE_FAILED,
-            metadata={'unresolved_files': 'file1'})
+            False, False, None, MergeFailureReason.MERGE_FAILED, metadata={"unresolved_files": "file1"}
+        )
 
         assert pull_request._last_merge_source_rev is None
         assert pull_request._last_merge_target_rev is None
@@ -198,13 +185,17 b' class TestPullRequestModel(object):'
 
         merge_response, status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
-        assert msg == 'This pull request cannot be merged because of merge conflicts. file1'
+        assert msg == "This pull request cannot be merged because of merge conflicts. file1"
         self.merge_mock.assert_called_with(
-            self.repo_id, self.workspace_id,
+            self.repo_id,
+            self.workspace_id,
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
-            pull_request.source_ref_parts, dry_run=True,
-            use_rebase=False, close_branch=False)
+            pull_request.source_ref_parts,
+            dry_run=True,
+            use_rebase=False,
+            close_branch=False,
+        )
 
         assert pull_request._last_merge_source_rev == self.source_commit
         assert pull_request._last_merge_target_rev == self.target_commit
@@ -213,13 +204,13 b' class TestPullRequestModel(object):'
         self.merge_mock.reset_mock()
         merge_response, status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
-        assert msg == 'This pull request cannot be merged because of merge conflicts. file1'
+        assert msg == "This pull request cannot be merged because of merge conflicts. file1"
         assert self.merge_mock.called is False
 
     def test_merge_status_unknown_failure(self, pull_request):
         self.merge_mock.return_value = MergeResponse(
-            False, False, None, MergeFailureReason.UNKNOWN,
-            metadata={'exception': 'MockError'})
+            False, False, None, MergeFailureReason.UNKNOWN, metadata={"exception": "MockError"}
+        )
 
         assert pull_request._last_merge_source_rev is None
         assert pull_request._last_merge_target_rev is None
@@ -227,15 +218,17 b' class TestPullRequestModel(object):'
 
         merge_response, status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
-        assert msg == (
-            'This pull request cannot be merged because of an unhandled exception. '
-            'MockError')
+        assert msg == "This pull request cannot be merged because of an unhandled exception. MockError"
         self.merge_mock.assert_called_with(
-            self.repo_id, self.workspace_id,
+            self.repo_id,
+            self.workspace_id,
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
-            pull_request.source_ref_parts, dry_run=True,
-            use_rebase=False, close_branch=False)
+            pull_request.source_ref_parts,
+            dry_run=True,
+            use_rebase=False,
+            close_branch=False,
+        )
 
         assert pull_request._last_merge_source_rev is None
         assert pull_request._last_merge_target_rev is None
@@ -244,155 +237,136 b' class TestPullRequestModel(object):'
         self.merge_mock.reset_mock()
         merge_response, status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
-        assert msg == (
-            'This pull request cannot be merged because of an unhandled exception. '
-            'MockError')
+        assert msg == "This pull request cannot be merged because of an unhandled exception. MockError"
         assert self.merge_mock.called is True
 
     def test_merge_status_when_target_is_locked(self, pull_request):
-        pull_request.target_repo.locked = [1, u'12345.50', 'lock_web']
+        pull_request.target_repo.locked = [1, "12345.50", "lock_web"]
         merge_response, status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
-        assert msg == (
-            'This pull request cannot be merged because the target repository '
-            'is locked by user:1.')
+        assert msg == "This pull request cannot be merged because the target repository is locked by user:1."
 
     def test_merge_status_requirements_check_target(self, pull_request):
-
         def has_largefiles(self, repo):
             return repo == pull_request.source_repo
 
-        patcher = mock.patch.object(PullRequestModel, '_has_largefiles', has_largefiles)
+        patcher = mock.patch.object(PullRequestModel, "_has_largefiles", has_largefiles)
         with patcher:
             merge_response, status, msg = PullRequestModel().merge_status(pull_request)
 
         assert status is False
-        assert msg == 'Target repository large files support is disabled.'
+        assert msg == "Target repository large files support is disabled."
 
     def test_merge_status_requirements_check_source(self, pull_request):
-
         def has_largefiles(self, repo):
             return repo == pull_request.target_repo
 
-        patcher = mock.patch.object(PullRequestModel, '_has_largefiles', has_largefiles)
+        patcher = mock.patch.object(PullRequestModel, "_has_largefiles", has_largefiles)
         with patcher:
             merge_response, status, msg = PullRequestModel().merge_status(pull_request)
 
         assert status is False
-        assert msg == 'Source repository large files support is disabled.'
+        assert msg == "Source repository large files support is disabled."
 
     def test_merge(self, pull_request, merge_extras):
         user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
-        merge_ref = Reference(
-            'type', 'name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
-        self.merge_mock.return_value = MergeResponse(
-            True, True, merge_ref, MergeFailureReason.NONE)
+        merge_ref = Reference("type", "name", "6126b7bfcc82ad2d3deaee22af926b082ce54cc6")
+        self.merge_mock.return_value = MergeResponse(True, True, merge_ref, MergeFailureReason.NONE)
 
-        merge_extras['repository'] = pull_request.target_repo.repo_name
-        PullRequestModel().merge_repo(
-            pull_request, pull_request.author, extras=merge_extras)
+        merge_extras["repository"] = pull_request.target_repo.repo_name
+        PullRequestModel().merge_repo(pull_request, pull_request.author, extras=merge_extras)
         Session().commit()
 
-        message = (
-            u'Merge pull request !{pr_id} from {source_repo} {source_ref_name}'
-            u'\n\n {pr_title}'.format(
-                pr_id=pull_request.pull_request_id,
-                source_repo=safe_str(
-                    pull_request.source_repo.scm_instance().name),
-                source_ref_name=pull_request.source_ref_parts.name,
-                pr_title=safe_str(pull_request.title)
-            )
+        message = "Merge pull request !{pr_id} from {source_repo} {source_ref_name}" "\n\n {pr_title}".format(
+            pr_id=pull_request.pull_request_id,
+            source_repo=safe_str(pull_request.source_repo.scm_instance().name),
+            source_ref_name=pull_request.source_ref_parts.name,
+            pr_title=safe_str(pull_request.title),
         )
         self.merge_mock.assert_called_with(
-            self.repo_id, self.workspace_id,
+            self.repo_id,
+            self.workspace_id,
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts,
-            user_name=user.short_contact, user_email=user.email, message=message,
-            use_rebase=False, close_branch=False
+            user_name=user.short_contact,
+            user_email=user.email,
+            message=message,
+            use_rebase=False,
+            close_branch=False,
         )
-        self.invalidation_mock.assert_called_once_with(
-            pull_request.target_repo.repo_name)
+        self.invalidation_mock.assert_called_once_with(pull_request.target_repo.repo_name)
 
-        self.hook_mock.assert_called_with(
-            self.pull_request, self.pull_request.author, 'merge')
+        self.hook_mock.assert_called_with(self.pull_request, self.pull_request.author, "merge")
 
         pull_request = PullRequest.get(pull_request.pull_request_id)
-        assert pull_request.merge_rev == '6126b7bfcc82ad2d3deaee22af926b082ce54cc6'
+        assert pull_request.merge_rev == "6126b7bfcc82ad2d3deaee22af926b082ce54cc6"
 
     def test_merge_with_status_lock(self, pull_request, merge_extras):
         user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
-        merge_ref = Reference(
-            'type', 'name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
-        self.merge_mock.return_value = MergeResponse(
-            True, True, merge_ref, MergeFailureReason.NONE)
+        merge_ref = Reference("type", "name", "6126b7bfcc82ad2d3deaee22af926b082ce54cc6")
+        self.merge_mock.return_value = MergeResponse(True, True, merge_ref, MergeFailureReason.NONE)
 
-        merge_extras['repository'] = pull_request.target_repo.repo_name
+        merge_extras["repository"] = pull_request.target_repo.repo_name
 
         with pull_request.set_state(PullRequest.STATE_UPDATING):
             assert pull_request.pull_request_state == PullRequest.STATE_UPDATING
-            PullRequestModel().merge_repo(
-                pull_request, pull_request.author, extras=merge_extras)
+            PullRequestModel().merge_repo(pull_request, pull_request.author, extras=merge_extras)
             Session().commit()
 
         assert pull_request.pull_request_state == PullRequest.STATE_CREATED
 
-        message = (
-            u'Merge pull request !{pr_id} from {source_repo} {source_ref_name}'
-            u'\n\n {pr_title}'.format(
-                pr_id=pull_request.pull_request_id,
-                source_repo=safe_str(
-                    pull_request.source_repo.scm_instance().name),
-                source_ref_name=pull_request.source_ref_parts.name,
-                pr_title=safe_str(pull_request.title)
-            )
+        message = "Merge pull request !{pr_id} from {source_repo} {source_ref_name}" "\n\n {pr_title}".format(
+            pr_id=pull_request.pull_request_id,
+            source_repo=safe_str(pull_request.source_repo.scm_instance().name),
+            source_ref_name=pull_request.source_ref_parts.name,
+            pr_title=safe_str(pull_request.title),
         )
         self.merge_mock.assert_called_with(
-            self.repo_id, self.workspace_id,
+            self.repo_id,
+            self.workspace_id,
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts,
-            user_name=user.short_contact, user_email=user.email, message=message,
-            use_rebase=False, close_branch=False
+            user_name=user.short_contact,
+            user_email=user.email,
+            message=message,
+            use_rebase=False,
+            close_branch=False,
         )
-        self.invalidation_mock.assert_called_once_with(
-            pull_request.target_repo.repo_name)
+        self.invalidation_mock.assert_called_once_with(pull_request.target_repo.repo_name)
 
-        self.hook_mock.assert_called_with(
-            self.pull_request, self.pull_request.author, 'merge')
+        self.hook_mock.assert_called_with(self.pull_request, self.pull_request.author, "merge")
 
         pull_request = PullRequest.get(pull_request.pull_request_id)
-        assert pull_request.merge_rev == '6126b7bfcc82ad2d3deaee22af926b082ce54cc6'
+        assert pull_request.merge_rev == "6126b7bfcc82ad2d3deaee22af926b082ce54cc6"
 
     def test_merge_failed(self, pull_request, merge_extras):
         user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
-        merge_ref = Reference(
-            'type', 'name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
-        self.merge_mock.return_value = MergeResponse(
-            False, False, merge_ref, MergeFailureReason.MERGE_FAILED)
+        merge_ref = Reference("type", "name", "6126b7bfcc82ad2d3deaee22af926b082ce54cc6")
+        self.merge_mock.return_value = MergeResponse(False, False, merge_ref, MergeFailureReason.MERGE_FAILED)
 
-        merge_extras['repository'] = pull_request.target_repo.repo_name
-        PullRequestModel().merge_repo(
-            pull_request, pull_request.author, extras=merge_extras)
+        merge_extras["repository"] = pull_request.target_repo.repo_name
+        PullRequestModel().merge_repo(pull_request, pull_request.author, extras=merge_extras)
         Session().commit()
 
-        message = (
-            u'Merge pull request !{pr_id} from {source_repo} {source_ref_name}'
-            u'\n\n {pr_title}'.format(
-                pr_id=pull_request.pull_request_id,
-                source_repo=safe_str(
-                    pull_request.source_repo.scm_instance().name),
-                source_ref_name=pull_request.source_ref_parts.name,
-                pr_title=safe_str(pull_request.title)
-            )
+        message = "Merge pull request !{pr_id} from {source_repo} {source_ref_name}" "\n\n {pr_title}".format(
+            pr_id=pull_request.pull_request_id,
+            source_repo=safe_str(pull_request.source_repo.scm_instance().name),
+            source_ref_name=pull_request.source_ref_parts.name,
+            pr_title=safe_str(pull_request.title),
         )
         self.merge_mock.assert_called_with(
-            self.repo_id, self.workspace_id,
+            self.repo_id,
+            self.workspace_id,
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts,
-            user_name=user.short_contact, user_email=user.email, message=message,
-            use_rebase=False, close_branch=False
+            user_name=user.short_contact,
+            user_email=user.email,
+            message=message,
+            use_rebase=False,
+            close_branch=False,
         )
 
         pull_request = PullRequest.get(pull_request.pull_request_id)
@@ -410,7 +384,7 b' class TestPullRequestModel(object):'
         assert commit_ids == pull_request.revisions
 
         # Merge revision is not in the revisions list
-        pull_request.merge_rev = 'f000' * 10
+        pull_request.merge_rev = "f000" * 10
         commit_ids = PullRequestModel()._get_commit_ids(pull_request)
         assert commit_ids == pull_request.revisions + [pull_request.merge_rev]
 
@@ -419,147 +393,126 b' class TestPullRequestModel(object):'
         source_ref_id = pull_request.source_ref_parts.commit_id
         target_ref_id = pull_request.target_ref_parts.commit_id
         diff = PullRequestModel()._get_diff_from_pr_or_version(
-            source_repo, source_ref_id, target_ref_id,
-            hide_whitespace_changes=False, diff_context=6)
-        assert b'file_1' in diff.raw.tobytes()
+            source_repo, source_ref_id, target_ref_id, hide_whitespace_changes=False, diff_context=6
+        )
+        assert b"file_1" in diff.raw.tobytes()
 
     def test_generate_title_returns_unicode(self):
         title = PullRequestModel().generate_pullrequest_title(
-            source='source-dummy',
-            source_ref='source-ref-dummy',
-            target='target-dummy',
+            source="source-dummy",
+            source_ref="source-ref-dummy",
+            target="target-dummy",
         )
         assert type(title) == str
 
-    @pytest.mark.parametrize('title, has_wip', [
-        ('hello', False),
-        ('hello wip', False),
-        ('hello wip: xxx', False),
-        ('[wip] hello', True),
-        ('[wip] hello', True),
-        ('wip: hello', True),
-        ('wip hello', True),
-
-    ])
+    @pytest.mark.parametrize(
+        "title, has_wip",
+        [
+            ("hello", False),
+            ("hello wip", False),
+            ("hello wip: xxx", False),
+            ("[wip] hello", True),
+            ("[wip] hello", True),
+            ("wip: hello", True),
+            ("wip hello", True),
+        ],
+    )
     def test_wip_title_marker(self, pull_request, title, has_wip):
         pull_request.title = title
         assert pull_request.work_in_progress == has_wip
 
 
[e-mail]('config_stub')
[e-mail]("config_stub")
 class TestIntegrationMerge(object):
-    @pytest.mark.parametrize('extra_config', (
-        {'vcs.hooks.protocol.v2': 'celery', 'vcs.hooks.direct_calls': False},
-    ))
-    def test_merge_triggers_push_hooks(
-            self, pr_util, user_admin, capture_rcextensions, merge_extras,
-            extra_config):
-
-        pull_request = pr_util.create_pull_request(
-            approved=True, mergeable=True)
-        # TODO: johbo: Needed for sqlite, try to find an automatic way for it
-        merge_extras['repository'] = pull_request.target_repo.repo_name
-        Session().commit()
-
-        with mock.patch.dict(rhodecode.CONFIG, extra_config, clear=False):
-            merge_state = PullRequestModel().merge_repo(
-                pull_request, user_admin, extras=merge_extras)
-            Session().commit()
-
-        assert merge_state.executed
-        assert '_pre_push_hook' in capture_rcextensions
-        assert '_push_hook' in capture_rcextensions
 
-    def test_merge_can_be_rejected_by_pre_push_hook(
-            self, pr_util, user_admin, capture_rcextensions, merge_extras):
-        pull_request = pr_util.create_pull_request(
-            approved=True, mergeable=True)
-        # TODO: johbo: Needed for sqlite, try to find an automatic way for it
-        merge_extras['repository'] = pull_request.target_repo.repo_name
-        Session().commit()
-
-        with mock.patch('rhodecode.EXTENSIONS.PRE_PUSH_HOOK') as pre_pull:
-            pre_pull.side_effect = RepositoryError("Disallow push!")
-            merge_status = PullRequestModel().merge_repo(
-                pull_request, user_admin, extras=merge_extras)
-            Session().commit()
-
-        assert not merge_status.executed
-        assert 'pre_push' not in capture_rcextensions
-        assert 'post_push' not in capture_rcextensions
-
-    def test_merge_fails_if_target_is_locked(
-            self, pr_util, user_regular, merge_extras):
-        pull_request = pr_util.create_pull_request(
-            approved=True, mergeable=True)
-        locked_by = [user_regular.user_id + 1, 12345.50, 'lock_web']
+    def test_merge_fails_if_target_is_locked(self, pr_util, user_regular, merge_extras):
+        pull_request = pr_util.create_pull_request(approved=True, mergeable=True)
+        locked_by = [user_regular.user_id + 1, 12345.50, "lock_web"]
         pull_request.target_repo.locked = locked_by
         # TODO: johbo: Check if this can work based on the database, currently
         # all data is pre-computed, that's why just updating the DB is not
         # enough.
-        merge_extras['locked_by'] = locked_by
-        merge_extras['repository'] = pull_request.target_repo.repo_name
+        merge_extras["locked_by"] = locked_by
+        merge_extras["repository"] = pull_request.target_repo.repo_name
         # TODO: johbo: Needed for sqlite, try to find an automatic way for it
         Session().commit()
-        merge_status = PullRequestModel().merge_repo(
-            pull_request, user_regular, extras=merge_extras)
+        merge_status = PullRequestModel().merge_repo(pull_request, user_regular, extras=merge_extras)
         Session().commit()
 
         assert not merge_status.executed
 
 
[e-mail]('use_outdated, inlines_count, outdated_count', [
-    (False, 1, 0),
-    (True, 0, 1),
-])
-def test_outdated_comments(
-        pr_util, use_outdated, inlines_count, outdated_count, config_stub):
[e-mail](
+    "use_outdated, inlines_count, outdated_count",
+    [
+        (False, 1, 0),
+        (True, 0, 1),
+    ],
+)
+def test_outdated_comments(pr_util, use_outdated, inlines_count, outdated_count, config_stub):
     pull_request = pr_util.create_pull_request()
-    pr_util.create_inline_comment(file_path='not_in_updated_diff')
+    pr_util.create_inline_comment(file_path="not_in_updated_diff")
 
     with outdated_comments_patcher(use_outdated) as outdated_comment_mock:
         pr_util.add_one_commit()
-        assert_inline_comments(
-            pull_request, visible=inlines_count, outdated=outdated_count)
+        assert_inline_comments(pull_request, visible=inlines_count, outdated=outdated_count)
     outdated_comment_mock.assert_called_with(pull_request)
 
 
[e-mail]('mr_type, expected_msg', [
-    (MergeFailureReason.NONE,
-     'This pull request can be automatically merged.'),
-    (MergeFailureReason.UNKNOWN,
-     'This pull request cannot be merged because of an unhandled exception. CRASH'),
-    (MergeFailureReason.MERGE_FAILED,
-     'This pull request cannot be merged because of merge conflicts. CONFLICT_FILE'),
-    (MergeFailureReason.PUSH_FAILED,
-     'This pull request could not be merged because push to target:`some-repo@merge_commit` failed.'),
-    (MergeFailureReason.TARGET_IS_NOT_HEAD,
-     'This pull request cannot be merged because the target `ref_name` is not a head.'),
-    (MergeFailureReason.HG_SOURCE_HAS_MORE_BRANCHES,
-     'This pull request cannot be merged because the source contains more branches than the target.'),
-    (MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS,
-     'This pull request cannot be merged because the target `ref_name` has multiple heads: `a,b,c`.'),
-    (MergeFailureReason.TARGET_IS_LOCKED,
-     'This pull request cannot be merged because the target repository is locked by user:123.'),
-    (MergeFailureReason.MISSING_TARGET_REF,
-     'This pull request cannot be merged because the target reference `ref_name` is missing.'),
-    (MergeFailureReason.MISSING_SOURCE_REF,
-     'This pull request cannot be merged because the source reference `ref_name` is missing.'),
-    (MergeFailureReason.SUBREPO_MERGE_FAILED,
-     'This pull request cannot be merged because of conflicts related to sub repositories.'),
-
-])
[e-mail](
+    "mr_type, expected_msg",
+    [
+        (MergeFailureReason.NONE, "This pull request can be automatically merged."),
+        (MergeFailureReason.UNKNOWN, "This pull request cannot be merged because of an unhandled exception. CRASH"),
+        (
+            MergeFailureReason.MERGE_FAILED,
+            "This pull request cannot be merged because of merge conflicts. CONFLICT_FILE",
+        ),
+        (
+            MergeFailureReason.PUSH_FAILED,
+            "This pull request could not be merged because push to target:`some-repo@merge_commit` failed.",
+        ),
+        (
+            MergeFailureReason.TARGET_IS_NOT_HEAD,
+            "This pull request cannot be merged because the target `ref_name` is not a head.",
+        ),
+        (
+            MergeFailureReason.HG_SOURCE_HAS_MORE_BRANCHES,
+            "This pull request cannot be merged because the source contains more branches than the target.",
+        ),
+        (
+            MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS,
+            "This pull request cannot be merged because the target `ref_name` has multiple heads: `a,b,c`.",
+        ),
+        (
+            MergeFailureReason.TARGET_IS_LOCKED,
+            "This pull request cannot be merged because the target repository is locked by user:123.",
+        ),
+        (
+            MergeFailureReason.MISSING_TARGET_REF,
+            "This pull request cannot be merged because the target reference `ref_name` is missing.",
+        ),
+        (
+            MergeFailureReason.MISSING_SOURCE_REF,
+            "This pull request cannot be merged because the source reference `ref_name` is missing.",
+        ),
+        (
+            MergeFailureReason.SUBREPO_MERGE_FAILED,
+            "This pull request cannot be merged because of conflicts related to sub repositories.",
+        ),
+    ],
+)
 def test_merge_response_message(mr_type, expected_msg):
-    merge_ref = Reference('type', 'ref_name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
+    merge_ref = Reference("type", "ref_name", "6126b7bfcc82ad2d3deaee22af926b082ce54cc6")
     metadata = {
-        'unresolved_files': 'CONFLICT_FILE',
-        'exception': "CRASH",
-        'target': 'some-repo',
-        'merge_commit': 'merge_commit',
-        'target_ref': merge_ref,
-        'source_ref': merge_ref,
-        'heads': ','.join(['a', 'b', 'c']),
-        'locked_by': 'user:123'
+        "unresolved_files": "CONFLICT_FILE",
+        "exception": "CRASH",
+        "target": "some-repo",
+        "merge_commit": "merge_commit",
+        "target_ref": merge_ref,
+        "source_ref": merge_ref,
+        "heads": ",".join(["a", "b", "c"]),
+        "locked_by": "user:123",
     }
 
     merge_response = MergeResponse(True, True, merge_ref, mr_type, metadata=metadata)
@@ -573,30 +526,28 b' def merge_extras(request, user_regular):'
     """
 
     extras = {
-        'ip': '127.0.0.1',
-        'username': user_regular.username,
-        'user_id': user_regular.user_id,
-        'action': 'push',
-        'repository': 'fake_target_repo_name',
-        'scm': 'git',
-        'config': request.config.getini('pyramid_config'),
-        'repo_store': '',
-        'make_lock': None,
-        'locked_by': [None, None, None],
-        'server_url': 'http://test.example.com:5000',
-        'hooks': ['push', 'pull'],
-        'is_shadow_repo': False,
+        "ip": "127.0.0.1",
+        "username": user_regular.username,
+        "user_id": user_regular.user_id,
+        "action": "push",
+        "repository": "fake_target_repo_name",
+        "scm": "git",
+        "config": request.config.getini("pyramid_config"),
+        "repo_store": "",
+        "make_lock": None,
+        "locked_by": [None, None, None],
+        "server_url": "http://test.example.com:5000",
+        "hooks": ["push", "pull"],
+        "is_shadow_repo": False,
     }
     return extras
 
 
[e-mail]('config_stub')
[e-mail]("config_stub")
 class TestUpdateCommentHandling(object):
-
-    @pytest.fixture(autouse=True, scope='class')
+    @pytest.fixture(autouse=True, scope="class")
     def enable_outdated_comments(self, request, baseapp):
-        config_patch = mock.patch.dict(
-            'rhodecode.CONFIG', {'rhodecode_use_outdated_comments': True})
+        config_patch = mock.patch.dict("rhodecode.CONFIG", {"rhodecode_use_outdated_comments": True})
         config_patch.start()
 
         @request.addfinalizer
@@ -605,206 +556,194 b' class TestUpdateCommentHandling(object):'
 
     def test_comment_stays_unflagged_on_unchanged_diff(self, pr_util):
         commits = [
-            {'message': 'a'},
-            {'message': 'b', 'added': [FileNode(b'file_b', b'test_content\n')]},
-            {'message': 'c', 'added': [FileNode(b'file_c', b'test_content\n')]},
+            {"message": "a"},
+            {"message": "b", "added": [FileNode(b"file_b", b"test_content\n")]},
+            {"message": "c", "added": [FileNode(b"file_c", b"test_content\n")]},
         ]
-        pull_request = pr_util.create_pull_request(
-            commits=commits, target_head='a', source_head='b', revisions=['b'])
-        pr_util.create_inline_comment(file_path='file_b')
-        pr_util.add_one_commit(head='c')
+        pull_request = pr_util.create_pull_request(commits=commits, target_head="a", source_head="b", revisions=["b"])
+        pr_util.create_inline_comment(file_path="file_b")
+        pr_util.add_one_commit(head="c")
 
         assert_inline_comments(pull_request, visible=1, outdated=0)
 
     def test_comment_stays_unflagged_on_change_above(self, pr_util):
-        original_content = b''.join((b'line %d\n' % x for x in range(1, 11)))
-        updated_content = b'new_line_at_top\n' + original_content
+        original_content = b"".join((b"line %d\n" % x for x in range(1, 11)))
+        updated_content = b"new_line_at_top\n" + original_content
         commits = [
-            {'message': 'a'},
-            {'message': 'b', 'added': [FileNode(b'file_b', original_content)]},
-            {'message': 'c', 'changed': [FileNode(b'file_b', updated_content)]},
+            {"message": "a"},
+            {"message": "b", "added": [FileNode(b"file_b", original_content)]},
+            {"message": "c", "changed": [FileNode(b"file_b", updated_content)]},
         ]
-        pull_request = pr_util.create_pull_request(
-            commits=commits, target_head='a', source_head='b', revisions=['b'])
+        pull_request = pr_util.create_pull_request(commits=commits, target_head="a", source_head="b", revisions=["b"])
 
         with outdated_comments_patcher():
-            comment = pr_util.create_inline_comment(
-                line_no=u'n8', file_path='file_b')
-            pr_util.add_one_commit(head='c')
+            comment = pr_util.create_inline_comment(line_no="n8", file_path="file_b")
+            pr_util.add_one_commit(head="c")
 
         assert_inline_comments(pull_request, visible=1, outdated=0)
-        assert comment.line_no == u'n9'
+        assert comment.line_no == "n9"
 
     def test_comment_stays_unflagged_on_change_below(self, pr_util):
-        original_content = b''.join([b'line %d\n' % x for x in range(10)])
-        updated_content = original_content + b'new_line_at_end\n'
+        original_content = b"".join([b"line %d\n" % x for x in range(10)])
+        updated_content = original_content + b"new_line_at_end\n"
         commits = [
-            {'message': 'a'},
-            {'message': 'b', 'added': [FileNode(b'file_b', original_content)]},
-            {'message': 'c', 'changed': [FileNode(b'file_b', updated_content)]},
+            {"message": "a"},
+            {"message": "b", "added": [FileNode(b"file_b", original_content)]},
+            {"message": "c", "changed": [FileNode(b"file_b", updated_content)]},
         ]
-        pull_request = pr_util.create_pull_request(
-            commits=commits, target_head='a', source_head='b', revisions=['b'])
-        pr_util.create_inline_comment(file_path='file_b')
-        pr_util.add_one_commit(head='c')
+        pull_request = pr_util.create_pull_request(commits=commits, target_head="a", source_head="b", revisions=["b"])
+        pr_util.create_inline_comment(file_path="file_b")
+        pr_util.add_one_commit(head="c")
 
         assert_inline_comments(pull_request, visible=1, outdated=0)
 
-    @pytest.mark.parametrize('line_no', ['n4', 'o4', 'n10', 'o9'])
+    @pytest.mark.parametrize("line_no", ["n4", "o4", "n10", "o9"])
     def test_comment_flagged_on_change_around_context(self, pr_util, line_no):
-        base_lines = [b'line %d\n' % x for x in range(1, 13)]
+        base_lines = [b"line %d\n" % x for x in range(1, 13)]
         change_lines = list(base_lines)
-        change_lines.insert(6, b'line 6a added\n')
+        change_lines.insert(6, b"line 6a added\n")
 
         # Changes on the last line of sight
         update_lines = list(change_lines)
-        update_lines[0] = b'line 1 changed\n'
-        update_lines[-1] = b'line 12 changed\n'
+        update_lines[0] = b"line 1 changed\n"
+        update_lines[-1] = b"line 12 changed\n"
 
         def file_b(lines):
-            return FileNode(b'file_b', b''.join(lines))
+            return FileNode(b"file_b", b"".join(lines))
 
         commits = [
-            {'message': 'a', 'added': [file_b(base_lines)]},
-            {'message': 'b', 'changed': [file_b(change_lines)]},
-            {'message': 'c', 'changed': [file_b(update_lines)]},
+            {"message": "a", "added": [file_b(base_lines)]},
+            {"message": "b", "changed": [file_b(change_lines)]},
+            {"message": "c", "changed": [file_b(update_lines)]},
         ]
 
-        pull_request = pr_util.create_pull_request(
-            commits=commits, target_head='a', source_head='b', revisions=['b'])
-        pr_util.create_inline_comment(line_no=line_no, file_path='file_b')
+        pull_request = pr_util.create_pull_request(commits=commits, target_head="a", source_head="b", revisions=["b"])
+        pr_util.create_inline_comment(line_no=line_no, file_path="file_b")
 
         with outdated_comments_patcher():
-            pr_util.add_one_commit(head='c')
+            pr_util.add_one_commit(head="c")
             assert_inline_comments(pull_request, visible=0, outdated=1)
 
-    @pytest.mark.parametrize("change, content", [
-        ('changed', b'changed\n'),
-        ('removed', b''),
-    ], ids=['changed', b'removed'])
+    @pytest.mark.parametrize(
+        "change, content",
+        [
+            ("changed", b"changed\n"),
+            ("removed", b""),
+        ],
+        ids=["changed", b"removed"],
+    )
     def test_comment_flagged_on_change(self, pr_util, change, content):
         commits = [
-            {'message': 'a'},
-            {'message': 'b', 'added': [FileNode(b'file_b', b'test_content\n')]},
-            {'message': 'c', change: [FileNode(b'file_b', content)]},
+            {"message": "a"},
+            {"message": "b", "added": [FileNode(b"file_b", b"test_content\n")]},
+            {"message": "c", change: [FileNode(b"file_b", content)]},
         ]
-        pull_request = pr_util.create_pull_request(
-            commits=commits, target_head='a', source_head='b', revisions=['b'])
-        pr_util.create_inline_comment(file_path='file_b')
+        pull_request = pr_util.create_pull_request(commits=commits, target_head="a", source_head="b", revisions=["b"])
+        pr_util.create_inline_comment(file_path="file_b")
 
         with outdated_comments_patcher():
-            pr_util.add_one_commit(head='c')
+            pr_util.add_one_commit(head="c")
             assert_inline_comments(pull_request, visible=0, outdated=1)
 
 
[e-mail]('config_stub')
[e-mail]("config_stub")
 class TestUpdateChangedFiles(object):
-
     def test_no_changes_on_unchanged_diff(self, pr_util):
         commits = [
-            {'message': 'a'},
-            {'message': 'b',
-             'added': [FileNode(b'file_b', b'test_content b\n')]},
-            {'message': 'c',
-             'added': [FileNode(b'file_c', b'test_content c\n')]},
+            {"message": "a"},
+            {"message": "b", "added": [FileNode(b"file_b", b"test_content b\n")]},
+            {"message": "c", "added": [FileNode(b"file_c", b"test_content c\n")]},
         ]
         # open a PR from a to b, adding file_b
         pull_request = pr_util.create_pull_request(
-            commits=commits, target_head='a', source_head='b', revisions=['b'],
-            name_suffix='per-file-review')
+            commits=commits, target_head="a", source_head="b", revisions=["b"], name_suffix="per-file-review"
+        )
 
         # modify PR adding new file file_c
-        pr_util.add_one_commit(head='c')
+        pr_util.add_one_commit(head="c")
 
-        assert_pr_file_changes(
-            pull_request,
-            added=['file_c'],
-            modified=[],
-            removed=[])
+        assert_pr_file_changes(pull_request, added=["file_c"], modified=[], removed=[])
 
     def test_modify_and_undo_modification_diff(self, pr_util):
         commits = [
-            {'message': 'a'},
-            {'message': 'b',
-             'added': [FileNode(b'file_b', b'test_content b\n')]},
-            {'message': 'c',
-             'changed': [FileNode(b'file_b', b'test_content b modified\n')]},
-            {'message': 'd',
-             'changed': [FileNode(b'file_b', b'test_content b\n')]},
+            {"message": "a"},
+            {"message": "b", "added": [FileNode(b"file_b", b"test_content b\n")]},
+            {"message": "c", "changed": [FileNode(b"file_b", b"test_content b modified\n")]},
+            {"message": "d", "changed": [FileNode(b"file_b", b"test_content b\n")]},
         ]
         # open a PR from a to b, adding file_b
         pull_request = pr_util.create_pull_request(
-            commits=commits, target_head='a', source_head='b', revisions=['b'],
-            name_suffix='per-file-review')
+            commits=commits, target_head="a", source_head="b", revisions=["b"], name_suffix="per-file-review"
+        )
 
         # modify PR modifying file file_b
-        pr_util.add_one_commit(head='c')
+        pr_util.add_one_commit(head="c")
 
-        assert_pr_file_changes(
-            pull_request,
-            added=[],
-            modified=['file_b'],
-            removed=[])
+        assert_pr_file_changes(pull_request, added=[], modified=["file_b"], removed=[])
 
         # move the head again to d, which rollbacks change,
         # meaning we should indicate no changes
-        pr_util.add_one_commit(head='d')
+        pr_util.add_one_commit(head="d")
 
-        assert_pr_file_changes(
-            pull_request,
-            added=[],
-            modified=[],
-            removed=[])
+        assert_pr_file_changes(pull_request, added=[], modified=[], removed=[])
 
     def test_updated_all_files_in_pr(self, pr_util):
         commits = [
-            {'message': 'a'},
-            {'message': 'b', 'added': [
-                FileNode(b'file_a', b'test_content a\n'),
-                FileNode(b'file_b', b'test_content b\n'),
-                FileNode(b'file_c', b'test_content c\n')]},
-            {'message': 'c', 'changed': [
-                FileNode(b'file_a', b'test_content a changed\n'),
-                FileNode(b'file_b', b'test_content b changed\n'),
-                FileNode(b'file_c', b'test_content c changed\n')]},
+            {"message": "a"},
+            {
+                "message": "b",
+                "added": [
+                    FileNode(b"file_a", b"test_content a\n"),
+                    FileNode(b"file_b", b"test_content b\n"),
+                    FileNode(b"file_c", b"test_content c\n"),
+                ],
+            },
+            {
+                "message": "c",
+                "changed": [
+                    FileNode(b"file_a", b"test_content a changed\n"),
+                    FileNode(b"file_b", b"test_content b changed\n"),
+                    FileNode(b"file_c", b"test_content c changed\n"),
+                ],
+            },
         ]
         # open a PR from a to b, changing 3 files
         pull_request = pr_util.create_pull_request(
-            commits=commits, target_head='a', source_head='b', revisions=['b'],
-            name_suffix='per-file-review')
-
-        pr_util.add_one_commit(head='c')
+            commits=commits, target_head="a", source_head="b", revisions=["b"], name_suffix="per-file-review"
+        )
 
-        assert_pr_file_changes(
-            pull_request,
-            added=[],
-            modified=['file_a', 'file_b', 'file_c'],
-            removed=[])
+        pr_util.add_one_commit(head="c")
+
+        assert_pr_file_changes(pull_request, added=[], modified=["file_a", "file_b", "file_c"], removed=[])
 
     def test_updated_and_removed_all_files_in_pr(self, pr_util):
         commits = [
-            {'message': 'a'},
-            {'message': 'b', 'added': [
-                FileNode(b'file_a', b'test_content a\n'),
-                FileNode(b'file_b', b'test_content b\n'),
-                FileNode(b'file_c', b'test_content c\n')]},
-            {'message': 'c', 'removed': [
-                FileNode(b'file_a', b'test_content a changed\n'),
-                FileNode(b'file_b', b'test_content b changed\n'),
-                FileNode(b'file_c', b'test_content c changed\n')]},
+            {"message": "a"},
+            {
+                "message": "b",
+                "added": [
+                    FileNode(b"file_a", b"test_content a\n"),
+                    FileNode(b"file_b", b"test_content b\n"),
+                    FileNode(b"file_c", b"test_content c\n"),
+                ],
+            },
+            {
+                "message": "c",
+                "removed": [
+                    FileNode(b"file_a", b"test_content a changed\n"),
+                    FileNode(b"file_b", b"test_content b changed\n"),
+                    FileNode(b"file_c", b"test_content c changed\n"),
+                ],
+            },
         ]
         # open a PR from a to b, removing 3 files
         pull_request = pr_util.create_pull_request(
-            commits=commits, target_head='a', source_head='b', revisions=['b'],
-            name_suffix='per-file-review')
-
-        pr_util.add_one_commit(head='c')
+            commits=commits, target_head="a", source_head="b", revisions=["b"], name_suffix="per-file-review"
+        )
 
-        assert_pr_file_changes(
-            pull_request,
-            added=[],
-            modified=[],
-            removed=['file_a', 'file_b', 'file_c'])
+        pr_util.add_one_commit(head="c")
+
+        assert_pr_file_changes(pull_request, added=[], modified=[], removed=["file_a", "file_b", "file_c"])
 
 
 def test_update_writes_snapshot_into_pull_request_version(pr_util, config_stub):
@@ -866,8 +805,7 b' def test_update_adds_a_comment_to_the_pu'
 
         .. |under_review| replace:: *"Under Review"*"""
     ).format(commit_id[:12])
-    pull_request_comments = sorted(
-        pull_request.comments, key=lambda c: c.modified_at)
+    pull_request_comments = sorted(pull_request.comments, key=lambda c: c.modified_at)
     update_comment = pull_request_comments[-1]
     assert update_comment.text == expected_message
 
@@ -890,8 +828,8 b' def test_create_version_from_snapshot_up'
     version = PullRequestModel()._create_version_from_snapshot(pull_request)
 
     # Check attributes
-    assert version.title == pr_util.create_parameters['title']
-    assert version.description == pr_util.create_parameters['description']
+    assert version.title == pr_util.create_parameters["title"]
+    assert version.description == pr_util.create_parameters["description"]
     assert version.status == PullRequest.STATUS_CLOSED
 
     # versions get updated created_on
@@ -899,11 +837,11 b' def test_create_version_from_snapshot_up'
 
     assert version.updated_on == updated_on
     assert version.user_id == pull_request.user_id
-    assert version.revisions == pr_util.create_parameters['revisions']
+    assert version.revisions == pr_util.create_parameters["revisions"]
     assert version.source_repo == pr_util.source_repository
-    assert version.source_ref == pr_util.create_parameters['source_ref']
+    assert version.source_ref == pr_util.create_parameters["source_ref"]
     assert version.target_repo == pr_util.target_repository
-    assert version.target_ref == pr_util.create_parameters['target_ref']
+    assert version.target_ref == pr_util.create_parameters["target_ref"]
     assert version._last_merge_source_rev == pull_request._last_merge_source_rev
     assert version._last_merge_target_rev == pull_request._last_merge_target_rev
     assert version.last_merge_status == pull_request.last_merge_status
@@ -921,15 +859,9 b' def test_link_comments_to_version_only_u'
     Session().commit()
 
     # Expect that only the new comment is linked to version2
-    assert (
-        comment_unlinked.pull_request_version_id ==
-        version2.pull_request_version_id)
-    assert (
-        comment_linked.pull_request_version_id ==
-        version1.pull_request_version_id)
-    assert (
-        comment_unlinked.pull_request_version_id !=
-        comment_linked.pull_request_version_id)
+    assert comment_unlinked.pull_request_version_id == version2.pull_request_version_id
+    assert comment_linked.pull_request_version_id == version1.pull_request_version_id
+    assert comment_unlinked.pull_request_version_id != comment_linked.pull_request_version_id
 
 
 def test_calculate_commits():
@@ -945,35 +877,26 b' def test_calculate_commits():'
 def assert_inline_comments(pull_request, visible=None, outdated=None):
     if visible is not None:
         inline_comments = CommentsModel().get_inline_comments(
-            pull_request.target_repo.repo_id, pull_request=pull_request)
-        inline_cnt = len(CommentsModel().get_inline_comments_as_list(
-            inline_comments))
+            pull_request.target_repo.repo_id, pull_request=pull_request
+        )
+        inline_cnt = len(CommentsModel().get_inline_comments_as_list(inline_comments))
         assert inline_cnt == visible
     if outdated is not None:
-        outdated_comments = CommentsModel().get_outdated_comments(
-            pull_request.target_repo.repo_id, pull_request)
+        outdated_comments = CommentsModel().get_outdated_comments(pull_request.target_repo.repo_id, pull_request)
         assert len(outdated_comments) == outdated
 
 
-def assert_pr_file_changes(
-        pull_request, added=None, modified=None, removed=None):
+def assert_pr_file_changes(pull_request, added=None, modified=None, removed=None):
     pr_versions = PullRequestModel().get_versions(pull_request)
     # always use first version, ie original PR to calculate changes
     pull_request_version = pr_versions[0]
-    old_diff_data, new_diff_data = PullRequestModel()._generate_update_diffs(
-        pull_request, pull_request_version)
-    file_changes = PullRequestModel()._calculate_file_changes(
-        old_diff_data, new_diff_data)
+    old_diff_data, new_diff_data = PullRequestModel()._generate_update_diffs(pull_request, pull_request_version)
+    file_changes = PullRequestModel()._calculate_file_changes(old_diff_data, new_diff_data)
 
-    assert added == file_changes.added, \
-        'expected added:%s vs value:%s' % (added, file_changes.added)
-    assert modified == file_changes.modified, \
-        'expected modified:%s vs value:%s' % (modified, file_changes.modified)
-    assert removed == file_changes.removed, \
-        'expected removed:%s vs value:%s' % (removed, file_changes.removed)
+    assert added == file_changes.added, "expected added:%s vs value:%s" % (added, file_changes.added)
+    assert modified == file_changes.modified, "expected modified:%s vs value:%s" % (modified, file_changes.modified)
+    assert removed == file_changes.removed, "expected removed:%s vs value:%s" % (removed, file_changes.removed)
 
 
 def outdated_comments_patcher(use_outdated=True):
-    return mock.patch.object(
-        CommentsModel, 'use_outdated_comments',
-        return_value=use_outdated)
+    return mock.patch.object(CommentsModel, "use_outdated_comments", return_value=use_outdated)

rhodecode/tests/models/test_repo_groups.py

@@ -23,7 +23,7 b' from sqlalchemy.exc import IntegrityErro'
 import pytest
 
 from rhodecode.tests import TESTS_TMP_PATH
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.repo import RepoModel

rhodecode/tests/models/test_user_group_permissions_on_repo_groups.py

@@ -28,7 +28,7 b' from rhodecode.model.user_group import U'
 from rhodecode.tests.models.common import (
     _create_project_tree, check_tree_perms, _get_perms, _check_expected_count,
     expected_count, _destroy_project_tree)
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 
 
 fixture = Fixture()

rhodecode/tests/models/test_user_groups.py

@@ -22,7 +22,7 b' import pytest'
 
 from rhodecode.model.db import User
 from rhodecode.tests import TEST_USER_REGULAR_LOGIN
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.meta import Session
 

rhodecode/tests/models/test_users.py

@@ -27,7 +27,7 b' from rhodecode.model.user import UserMod'
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 from rhodecode.lib.str_utils import safe_str
 
 

rhodecode/tests/other/test_validators.py

@@ -32,11 +32,11 b' from rhodecode.model.meta import Session'
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.db import ChangesetStatus, Repository
 from rhodecode.model.changeset_status import ChangesetStatusModel
-from rhodecode.tests.fixture import Fixture
+from rhodecode.tests.fixtures.rc_fixture import Fixture
 
 fixture = Fixture()
 
-pytestmark = pytest.mark.usefixtures('baseapp')
+pytestmark = pytest.mark.usefixtures("baseapp")
 
 
 @pytest.fixture()

rhodecode/tests/rhodecode.ini

@@ -111,7 +111,7 b' app.base_url = http://rhodecode.local'
 app.service_api.host = http://rhodecode.local:10020
 
 ; Secret for Service API authentication.
-app.service_api.token =
+app.service_api.token = secret4
 
 ; Unique application ID. Should be a random unique string for security.
 app_instance_uuid = rc-production
@@ -351,7 +351,7 b' archive_cache.objectstore.retry_attempts'
 ; and served from the cache during subsequent requests for the same archive of
 ; the repository. This path is important to be shared across filesystems and with
 ; RhodeCode and vcsserver
-archive_cache.filesystem.store_dir = %(here)s/rc-tests/archive_cache
+archive_cache.filesystem.store_dir = %(here)s/.rc-test-data/archive_cache
 
 ; The limit in GB sets how much data we cache before recycling last used, defaults to 10 gb
 archive_cache.filesystem.cache_size_gb = 2
@@ -406,7 +406,7 b' celery.task_store_eager_result = true'
 
 ; Default cache dir for caches. Putting this into a ramdisk can boost performance.
 ; eg. /tmpfs/data_ramdisk, however this directory might require large amount of space
-cache_dir = %(here)s/rc-test-data
+cache_dir = %(here)s/.rc-test-data
 
 ; *********************************************
 ; `sql_cache_short` cache for heavy SQL queries
@@ -435,7 +435,7 b' rc_cache.cache_repo_longterm.max_size = '
 rc_cache.cache_general.backend = dogpile.cache.rc.file_namespace
 rc_cache.cache_general.expiration_time = 43200
 ; file cache store path. Defaults to `cache_dir =` value or tempdir if both values are not set
-rc_cache.cache_general.arguments.filename = %(here)s/rc-tests/cache-backend/cache_general_db
+rc_cache.cache_general.arguments.filename = %(here)s/.rc-test-data/cache-backend/cache_general_db
 
 ; alternative `cache_general` redis backend with distributed lock
 #rc_cache.cache_general.backend = dogpile.cache.rc.redis
@@ -454,6 +454,10 b' rc_cache.cache_general.arguments.filenam'
 ; auto-renew lock to prevent stale locks, slower but safer. Use only if problems happen
 #rc_cache.cache_general.arguments.lock_auto_renewal = true
 
+; prefix for redis keys used for this cache backend, the final key is constructed using {custom-prefix}{key}
+#rc_cache.cache_general.arguments.key_prefix = custom-prefix-
+
+
 ; *************************************************
 ; `cache_perms` cache for permission tree, auth TTL
 ; for simplicity use rc.file_namespace backend,
@@ -462,7 +466,7 b' rc_cache.cache_general.arguments.filenam'
 rc_cache.cache_perms.backend = dogpile.cache.rc.file_namespace
 rc_cache.cache_perms.expiration_time = 0
 ; file cache store path. Defaults to `cache_dir =` value or tempdir if both values are not set
-rc_cache.cache_perms.arguments.filename = %(here)s/rc-tests/cache-backend/cache_perms_db
+rc_cache.cache_perms.arguments.filename = %(here)s/.rc-test-data/cache-backend/cache_perms_db
 
 ; alternative `cache_perms` redis backend with distributed lock
 #rc_cache.cache_perms.backend = dogpile.cache.rc.redis
@@ -481,6 +485,10 b' rc_cache.cache_perms.arguments.filename '
 ; auto-renew lock to prevent stale locks, slower but safer. Use only if problems happen
 #rc_cache.cache_perms.arguments.lock_auto_renewal = true
 
+; prefix for redis keys used for this cache backend, the final key is constructed using {custom-prefix}{key}
+#rc_cache.cache_perms.arguments.key_prefix = custom-prefix-
+
+
 ; ***************************************************
 ; `cache_repo` cache for file tree, Readme, RSS FEEDS
 ; for simplicity use rc.file_namespace backend,
@@ -489,7 +497,7 b' rc_cache.cache_perms.arguments.filename '
 rc_cache.cache_repo.backend = dogpile.cache.rc.file_namespace
 rc_cache.cache_repo.expiration_time = 2592000
 ; file cache store path. Defaults to `cache_dir =` value or tempdir if both values are not set
-rc_cache.cache_repo.arguments.filename = %(here)s/rc-tests/cache-backend/cache_repo_db
+rc_cache.cache_repo.arguments.filename = %(here)s/.rc-test-data/cache-backend/cache_repo_db
 
 ; alternative `cache_repo` redis backend with distributed lock
 #rc_cache.cache_repo.backend = dogpile.cache.rc.redis
@@ -508,6 +516,10 b' rc_cache.cache_repo.arguments.filename ='
 ; auto-renew lock to prevent stale locks, slower but safer. Use only if problems happen
 #rc_cache.cache_repo.arguments.lock_auto_renewal = true
 
+; prefix for redis keys used for this cache backend, the final key is constructed using {custom-prefix}{key}
+#rc_cache.cache_repo.arguments.key_prefix = custom-prefix-
+
+
 ; ##############
 ; BEAKER SESSION
 ; ##############
@@ -516,7 +528,7 b' rc_cache.cache_repo.arguments.filename ='
 ; types are file, ext:redis, ext:database, ext:memcached
 ; Fastest ones are ext:redis and ext:database, DO NOT use memory type for session
 beaker.session.type = file
-beaker.session.data_dir = %(here)s/rc-tests/data/sessions
+beaker.session.data_dir = %(here)s/.rc-test-data/data/sessions
 
 ; Redis based sessions
 #beaker.session.type = ext:redis
@@ -532,7 +544,7 b' beaker.session.data_dir = %(here)s/rc-te'
 
 beaker.session.key = rhodecode
 beaker.session.secret = test-rc-uytcxaz
-beaker.session.lock_dir = %(here)s/rc-tests/data/sessions/lock
+beaker.session.lock_dir = %(here)s/.rc-test-data/data/sessions/lock
 
 ; Secure encrypted cookie. Requires AES and AES python libraries
 ; you must disable beaker.session.secret to use this
@@ -564,7 +576,7 b' beaker.session.secure = false'
 ; WHOOSH Backend, doesn't require additional services to run
 ; it works good with few dozen repos
 search.module = rhodecode.lib.index.whoosh
-search.location = %(here)s/rc-tests/data/index
+search.location = %(here)s/.rc-test-data/data/index
 
 ; ####################
 ; CHANNELSTREAM CONFIG
@@ -584,7 +596,7 b' channelstream.server = channelstream:980'
 ; see Nginx/Apache configuration examples in our docs
 channelstream.ws_url = ws://rhodecode.yourserver.com/_channelstream
 channelstream.secret = ENV_GENERATED
-channelstream.history.location = %(here)s/rc-tests/channelstream_history
+channelstream.history.location = %(here)s/.rc-test-data/channelstream_history
 
 ; Internal application path that Javascript uses to connect into.
 ; If you use proxy-prefix the prefix should be added before /_channelstream
@@ -601,7 +613,7 b' channelstream.proxy_path = /_channelstre'
 ; pymysql is an alternative driver for MySQL, use in case of problems with default one
 #sqlalchemy.db1.url = mysql+pymysql://root:qweqwe@localhost/rhodecode
 
-sqlalchemy.db1.url = sqlite:///%(here)s/rc-tests/rhodecode_test.db?timeout=30
+sqlalchemy.db1.url = sqlite:///%(here)s/.rc-test-data/rhodecode_test.db?timeout=30
 
 ; see sqlalchemy docs for other advanced settings
 ; print the sql statements to output
@@ -737,7 +749,7 b' ssh.generate_authorized_keyfile = true'
 ; Path to the authorized_keys file where the generate entries are placed.
 ; It is possible to have multiple key files specified in `sshd_config` e.g.
 ; AuthorizedKeysFile %h/.ssh/authorized_keys %h/.ssh/authorized_keys_rhodecode
-ssh.authorized_keys_file_path = %(here)s/rc-tests/authorized_keys_rhodecode
+ssh.authorized_keys_file_path = %(here)s/.rc-test-data/authorized_keys_rhodecode
 
 ; Command to execute the SSH wrapper. The binary is available in the
 ; RhodeCode installation directory.

rhodecode/tests/server_utils.py

@@ -24,13 +24,13 b' import tempfile'
 import pytest
 import subprocess
 import logging
-from urllib.request import urlopen
-from urllib.error import URLError
+import requests
 import configparser
 
 
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS
 from rhodecode.tests.utils import is_url_reachable
+from rhodecode.tests import console_printer
 
 log = logging.getLogger(__name__)
 
@@ -49,7 +49,7 b' def get_host_url(pyramid_config):'
 
 def assert_no_running_instance(url):
     if is_url_reachable(url):
-        print(f"Hint: Usually this means another instance of server "
+        console_printer(f"Hint: Usually this means another instance of server "
               f"is running in the background at {url}.")
         pytest.fail(f"Port is not free at {url}, cannot start server at")
 
@@ -58,8 +58,9 b' class ServerBase(object):'
     _args = []
     log_file_name = 'NOT_DEFINED.log'
     status_url_tmpl = 'http://{host}:{port}/_admin/ops/ping'
+    console_marker = " :warning: [green]pytest-setup[/green] "
 
-    def __init__(self, config_file, log_file):
+    def __init__(self, config_file, log_file, env):
         self.config_file = config_file
         config = configparser.ConfigParser()
         config.read(config_file)
@@ -69,10 +70,10 b' class ServerBase(object):'
         self._args = []
         self.log_file = log_file or os.path.join(
             tempfile.gettempdir(), self.log_file_name)
+        self.env = env
         self.process = None
         self.server_out = None
-        log.info("Using the {} configuration:{}".format(
-            self.__class__.__name__, config_file))
+        log.info(f"Using the {self.__class__.__name__} configuration:{config_file}")
 
         if not os.path.isfile(config_file):
             raise RuntimeError(f'Failed to get config at {config_file}')
@@ -110,18 +111,17 b' class ServerBase(object):'
 
         while time.time() - start < timeout:
             try:
-                urlopen(status_url)
+                requests.get(status_url)
                 break
-            except URLError:
+            except requests.exceptions.ConnectionError:
                 time.sleep(0.2)
         else:
             pytest.fail(
-                "Starting the {} failed or took more than {} "
-                "seconds. cmd: `{}`".format(
-                    self.__class__.__name__, timeout, self.command))
+                f"Starting the {self.__class__.__name__} failed or took more than {timeout} seconds."
+                f"cmd: `{self.command}`"
+            )
 
-        log.info('Server of {} ready at url {}'.format(
-            self.__class__.__name__, status_url))
+        log.info(f'Server of {self.__class__.__name__} ready at url {status_url}')
 
     def shutdown(self):
         self.process.kill()
@@ -130,7 +130,7 b' class ServerBase(object):'
 
     def get_log_file_with_port(self):
         log_file = list(self.log_file.partition('.log'))
-        log_file.insert(1, get_port(self.config_file))
+        log_file.insert(1, f'-{get_port(self.config_file)}')
         log_file = ''.join(log_file)
         return log_file
 
@@ -140,11 +140,12 b' class RcVCSServer(ServerBase):'
     Represents a running VCSServer instance.
     """
 
-    log_file_name = 'rc-vcsserver.log'
+    log_file_name = 'rhodecode-vcsserver.log'
     status_url_tmpl = 'http://{host}:{port}/status'
 
-    def __init__(self, config_file, log_file=None, workers='3'):
-        super(RcVCSServer, self).__init__(config_file, log_file)
+    def __init__(self, config_file, log_file=None, workers='3', env=None, info_prefix=''):
+        super(RcVCSServer, self).__init__(config_file, log_file, env)
+        self.info_prefix = info_prefix
         self._args = [
             'gunicorn',
             '--bind', self.bind_addr,
@@ -164,9 +165,10 b' class RcVCSServer(ServerBase):'
         host_url = self.host_url()
         assert_no_running_instance(host_url)
 
-        print(f'rhodecode-vcsserver starting at: {host_url}')
-        print(f'rhodecode-vcsserver command: {self.command}')
-        print(f'rhodecode-vcsserver logfile: {self.log_file}')
+        console_printer(f'{self.console_marker}{self.info_prefix}rhodecode-vcsserver starting at: {host_url}')
+        console_printer(f'{self.console_marker}{self.info_prefix}rhodecode-vcsserver command: {self.command}')
+        console_printer(f'{self.console_marker}{self.info_prefix}rhodecode-vcsserver logfile: {self.log_file}')
+        console_printer()
 
         self.process = subprocess.Popen(
             self._args, bufsize=0, env=env,
@@ -178,11 +180,12 b' class RcWebServer(ServerBase):'
     Represents a running RCE web server used as a test fixture.
     """
 
-    log_file_name = 'rc-web.log'
+    log_file_name = 'rhodecode-ce.log'
     status_url_tmpl = 'http://{host}:{port}/_admin/ops/ping'
 
-    def __init__(self, config_file, log_file=None, workers='2'):
-        super(RcWebServer, self).__init__(config_file, log_file)
+    def __init__(self, config_file, log_file=None, workers='2', env=None, info_prefix=''):
+        super(RcWebServer, self).__init__(config_file, log_file, env)
+        self.info_prefix = info_prefix
         self._args = [
             'gunicorn',
             '--bind', self.bind_addr,
@@ -195,7 +198,8 b' class RcWebServer(ServerBase):'
 
     def start(self):
         env = os.environ.copy()
-        env['RC_NO_TMP_PATH'] = '1'
+        if self.env:
+            env.update(self.env)
 
         self.log_file = self.get_log_file_with_port()
         self.server_out = open(self.log_file, 'w')
@@ -203,9 +207,10 b' class RcWebServer(ServerBase):'
         host_url = self.host_url()
         assert_no_running_instance(host_url)
 
-        print(f'rhodecode-web starting at: {host_url}')
-        print(f'rhodecode-web command: {self.command}')
-        print(f'rhodecode-web logfile: {self.log_file}')
+        console_printer(f'{self.console_marker}{self.info_prefix}rhodecode-ce starting at: {host_url}')
+        console_printer(f'{self.console_marker}{self.info_prefix}rhodecode-ce command: {self.command}')
+        console_printer(f'{self.console_marker}{self.info_prefix}rhodecode-ce logfile: {self.log_file}')
+        console_printer()
 
         self.process = subprocess.Popen(
             self._args, bufsize=0, env=env,
@@ -229,3 +234,44 b' class RcWebServer(ServerBase):'
         }
         params.update(**kwargs)
         return params['user'], params['passwd']
+
+class CeleryServer(ServerBase):
+    log_file_name = 'rhodecode-celery.log'
+    status_url_tmpl = 'http://{host}:{port}/_admin/ops/ping'
+
+    def __init__(self, config_file, log_file=None, workers='2', env=None, info_prefix=''):
+        super(CeleryServer, self).__init__(config_file, log_file, env)
+        self.info_prefix = info_prefix
+        self._args = \
+            ['celery',
+             '--no-color',
+             '--app=rhodecode.lib.celerylib.loader',
+             'worker',
+             '--autoscale=4,2',
+             '--max-tasks-per-child=30',
+             '--task-events',
+             '--loglevel=DEBUG',
+             '--ini=' + self.config_file]
+
+    def start(self):
+        env = os.environ.copy()
+        env['RC_NO_TEST_ENV'] = '1'
+
+        self.log_file = self.get_log_file_with_port()
+        self.server_out = open(self.log_file, 'w')
+
+        host_url = "Celery" #self.host_url()
+        #assert_no_running_instance(host_url)
+
+        console_printer(f'{self.console_marker}{self.info_prefix}rhodecode-celery starting at: {host_url}')
+        console_printer(f'{self.console_marker}{self.info_prefix}rhodecode-celery command: {self.command}')
+        console_printer(f'{self.console_marker}{self.info_prefix}rhodecode-celery logfile: {self.log_file}')
+        console_printer()
+
+        self.process = subprocess.Popen(
+            self._args, bufsize=0, env=env,
+            stdout=self.server_out, stderr=self.server_out)
+
+
+    def wait_until_ready(self, timeout=30):
+        time.sleep(2)

rhodecode/tests/utils.py

@@ -36,24 +36,29 b' from webtest.app import TestResponse, Te'
 
 import pytest
 
-try:
-    import rc_testdata
-except ImportError:
-    raise ImportError('Failed to import rc_testdata, '
-                      'please make sure this package is installed from requirements_test.txt')
-
 from rhodecode.model.db import User, Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.scm import ScmModel
 from rhodecode.lib.vcs.backends.svn.repository import SubversionRepository
 from rhodecode.lib.vcs.backends.base import EmptyCommit
-from rhodecode.tests import login_user_session
+from rhodecode.tests import login_user_session, console_printer
+from rhodecode.authentication import AuthenticationPluginRegistry
+from rhodecode.model.settings import SettingsModel
 
 log = logging.getLogger(__name__)
 
 
-def print_to_func(value, print_to=sys.stderr):
-    print(value, file=print_to)
+def console_printer_utils(msg):
+    console_printer(f" :white_check_mark: [green]test-utils[/green] {msg}")
+
+
+def get_rc_testdata():
+    try:
+        import rc_testdata
+    except ImportError:
+        raise ImportError('Failed to import rc_testdata, '
+                          'please make sure this package is installed from requirements_test.txt')
+    return rc_testdata
 
 
 class CustomTestResponse(TestResponse):
@@ -73,7 +78,6 b' class CustomTestResponse(TestResponse):'
             assert string in res
         """
         print_body = kw.pop('print_body', False)
-        print_to = kw.pop('print_to', sys.stderr)
 
         if 'no' in kw:
             no = kw['no']
@@ -89,18 +93,18 b' class CustomTestResponse(TestResponse):'
 
         for s in strings:
             if s not in self:
-                print_to_func(f"Actual response (no {s!r}):", print_to=print_to)
-                print_to_func(f"body output saved as `{f}`", print_to=print_to)
+                console_printer_utils(f"Actual response (no {s!r}):")
+                console_printer_utils(f"body output saved as `{f}`")
                 if print_body:
-                    print_to_func(str(self), print_to=print_to)
+                    console_printer_utils(str(self))
                 raise IndexError(f"Body does not contain string {s!r}, body output saved as {f}")
 
         for no_s in no:
             if no_s in self:
-                print_to_func(f"Actual response (has {no_s!r})", print_to=print_to)
-                print_to_func(f"body output saved as `{f}`", print_to=print_to)
+                console_printer_utils(f"Actual response (has {no_s!r})")
+                console_printer_utils(f"body output saved as `{f}`")
                 if print_body:
-                    print_to_func(str(self), print_to=print_to)
+                    console_printer_utils(str(self))
                 raise IndexError(f"Body contains bad string {no_s!r}, body output saved as {f}")
 
     def assert_response(self):
@@ -209,6 +213,7 b' def extract_git_repo_from_dump(dump_name'
     """Create git repo `repo_name` from dump `dump_name`."""
     repos_path = ScmModel().repos_path
     target_path = os.path.join(repos_path, repo_name)
+    rc_testdata = get_rc_testdata()
     rc_testdata.extract_git_dump(dump_name, target_path)
     return target_path
 
@@ -217,6 +222,7 b' def extract_hg_repo_from_dump(dump_name,'
     """Create hg repo `repo_name` from dump `dump_name`."""
     repos_path = ScmModel().repos_path
     target_path = os.path.join(repos_path, repo_name)
+    rc_testdata = get_rc_testdata()
     rc_testdata.extract_hg_dump(dump_name, target_path)
     return target_path
 
@@ -245,6 +251,7 b' def _load_svn_dump_into_repo(dump_name, '
     Currently the dumps are in rc_testdata. They might later on be
     integrated with the main repository once they stabilize more.
     """
+    rc_testdata = get_rc_testdata()
     dump = rc_testdata.load_svn_dump(dump_name)
     load_dump = subprocess.Popen(
         ['svnadmin', 'load', repo_path],
@@ -254,9 +261,7 b' def _load_svn_dump_into_repo(dump_name, '
     if load_dump.returncode != 0:
         log.error("Output of load_dump command: %s", out)
         log.error("Error output of load_dump command: %s", err)
-        raise Exception(
-            'Failed to load dump "%s" into repository at path "%s".'
-            % (dump_name, repo_path))
+        raise Exception(f'Failed to load dump "{dump_name}" into repository at path "{repo_path}".')
 
 
 class AssertResponse(object):
@@ -492,3 +497,54 b' def permission_update_data_generator(csr'
                 ('perm_del_member_type_{}'.format(obj_id), obj_type),
             ])
     return form_data
+
+
+
+class AuthPluginManager:
+
+    def cleanup(self):
+        self._enable_plugins(['egg:rhodecode-enterprise-ce#rhodecode'])
+
+    def enable(self, plugins_list, override=None):
+        return self._enable_plugins(plugins_list, override)
+
+    @classmethod
+    def _enable_plugins(cls, plugins_list, override: object = None):
+        override = override or {}
+        params = {
+            'auth_plugins': ','.join(plugins_list),
+        }
+
+        # helper translate some names to others, to fix settings code
+        name_map = {
+            'token': 'authtoken'
+        }
+        log.debug('enable_auth_plugins: enabling following auth-plugins: %s', plugins_list)
+
+        for module in plugins_list:
+            plugin_name = module.partition('#')[-1]
+            if plugin_name in name_map:
+                plugin_name = name_map[plugin_name]
+            enabled_plugin = f'auth_{plugin_name}_enabled'
+            cache_ttl = f'auth_{plugin_name}_cache_ttl'
+
+            # default params that are needed for each plugin,
+            # `enabled` and `cache_ttl`
+            params.update({
+                enabled_plugin: True,
+                cache_ttl: 0
+            })
+            if override.get:
+                params.update(override.get(module, {}))
+
+            validated_params = params
+
+            for k, v in validated_params.items():
+                setting = SettingsModel().create_or_update_setting(k, v)
+                Session().add(setting)
+            Session().commit()
+
+        AuthenticationPluginRegistry.invalidate_auth_plugins_cache(hard=True)
+
+        enabled_plugins = SettingsModel().get_auth_plugins()
+        assert plugins_list == enabled_plugins

rhodecode/tests/vcs/__init__.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify

rhodecode/tests/vcs/conftest.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -32,8 +31,7 b' from rhodecode.tests.utils import check_'
 
 
 @pytest.fixture()
-def vcs_repository_support(
-        request, backend_alias, baseapp, _vcs_repo_container):
+def vcs_repository_support(request, backend_alias, baseapp, _vcs_repo_container):
     """
     Provide a test repository for the test run.
 
@@ -63,7 +61,7 b' def vcs_repository_support('
     return backend_alias, repo
 
 
[e-mail](scope='class')
[e-mail](scope="class")
 def _vcs_repo_container(request):
     """
     Internal fixture intended to help support class based scoping on demand.
@@ -73,13 +71,12 b' def _vcs_repo_container(request):'
 
 def _create_vcs_repo_container(request):
     repo_container = VcsRepoContainer()
-    if not request.config.getoption('--keep-tmp-path'):
+    if not request.config.getoption("--keep-tmp-path"):
         request.addfinalizer(repo_container.cleanup)
     return repo_container
 
 
 class VcsRepoContainer(object):
-
     def __init__(self):
         self._cleanup_paths = []
         self._repos = {}
@@ -98,14 +95,14 b' class VcsRepoContainer(object):'
 
 
 def _should_create_repo_per_test(cls):
-    return getattr(cls, 'recreate_repo_per_test', False)
+    return getattr(cls, "recreate_repo_per_test", False)
 
 
 def _create_empty_repository(cls, backend_alias=None):
     Backend = get_backend(backend_alias or cls.backend_alias)
     repo_path = get_new_dir(str(time.time()))
     repo = Backend(repo_path, create=True)
-    if hasattr(cls, '_get_commits'):
+    if hasattr(cls, "_get_commits"):
         commits = cls._get_commits()
         cls.tip = _add_commits_to_repo(repo, commits)
 
@@ -127,7 +124,7 b' def config():'
     specific content is required.
     """
     config = Config()
-    config.set('section-a', 'a-1', 'value-a-1')
+    config.set("section-a", "a-1", "value-a-1")
     return config
 
 
@@ -136,24 +133,24 b' def _add_commits_to_repo(repo, commits):'
     tip = None
 
     for commit in commits:
-        for node in commit.get('added', []):
+        for node in commit.get("added", []):
             if not isinstance(node, FileNode):
                 node = FileNode(safe_bytes(node.path), content=node.content)
             imc.add(node)
 
-        for node in commit.get('changed', []):
+        for node in commit.get("changed", []):
             if not isinstance(node, FileNode):
                 node = FileNode(safe_bytes(node.path), content=node.content)
             imc.change(node)
 
-        for node in commit.get('removed', []):
+        for node in commit.get("removed", []):
             imc.remove(FileNode(safe_bytes(node.path)))
 
         tip = imc.commit(
-            message=str(commit['message']),
-            author=str(commit['author']),
-            date=commit['date'],
-            branch=commit.get('branch')
+            message=str(commit["message"]),
+            author=str(commit["author"]),
+            date=commit["date"],
+            branch=commit.get("branch"),
         )
 
     return tip
@@ -183,16 +180,15 b' def generate_repo_with_commits(vcs_repo)'
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in range(num):
             yield {
-                'message': 'Commit %d' % x,
-                'author': 'Joe Doe <[e-mail]>',
-                'date': start_date + datetime.timedelta(hours=12 * x),
-                'added': [
-                    FileNode(b'file_%d.txt' % x, content=b'Foobar %d' % x),
+                "message": "Commit %d" % x,
+                "author": "Joe Doe <[e-mail]>",
+                "date": start_date + datetime.timedelta(hours=12 * x),
+                "added": [
+                    FileNode(b"file_%d.txt" % x, content=b"Foobar %d" % x),
                 ],
-                'modified': [
-                    FileNode(b'file_%d.txt' % x,
-                             content=b'Foobar %d modified' % (x-1)),
-                ]
+                "modified": [
+                    FileNode(b"file_%d.txt" % x, content=b"Foobar %d modified" % (x - 1)),
+                ],
             }
 
     def commit_maker(num=5):
@@ -231,34 +227,33 b' class BackendTestMixin(object):'
       created
       before every single test. Defaults to ``True``.
     """
+
     recreate_repo_per_test = True
 
     @classmethod
     def _get_commits(cls):
         commits = [
             {
-                'message': 'Initial commit',
-                'author': 'Joe Doe <[e-mail]>',
-                'date': datetime.datetime(2010, 1, 1, 20),
-                'added': [
-                    FileNode(b'foobar', content=b'Foobar'),
-                    FileNode(b'foobar2', content=b'Foobar II'),
-                    FileNode(b'foo/bar/baz', content=b'baz here!'),
+                "message": "Initial commit",
+                "author": "Joe Doe <[e-mail]>",
+                "date": datetime.datetime(2010, 1, 1, 20),
+                "added": [
+                    FileNode(b"foobar", content=b"Foobar"),
+                    FileNode(b"foobar2", content=b"Foobar II"),
+                    FileNode(b"foo/bar/baz", content=b"baz here!"),
                 ],
             },
             {
-                'message': 'Changes...',
-                'author': 'Jane Doe <[e-mail]>',
-                'date': datetime.datetime(2010, 1, 1, 21),
-                'added': [
-                    FileNode(b'some/new.txt', content=b'news...'),
+                "message": "Changes...",
+                "author": "Jane Doe <[e-mail]>",
+                "date": datetime.datetime(2010, 1, 1, 21),
+                "added": [
+                    FileNode(b"some/new.txt", content=b"news..."),
                 ],
-                'changed': [
-                    FileNode(b'foobar', b'Foobar I'),
+                "changed": [
+                    FileNode(b"foobar", b"Foobar I"),
                 ],
-                'removed': [],
+                "removed": [],
             },
         ]
         return commits
-
-

rhodecode/tests/vcs/test_archives.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -43,121 +42,120 b' def d_cache_config():'
 
 @pytest.mark.usefixtures("vcs_repository_support")
 class TestArchives(BackendTestMixin):
-
     @classmethod
     def _get_commits(cls):
         start_date = datetime.datetime(2010, 1, 1, 20)
         yield {
-            'message': 'Initial Commit',
-            'author': 'Joe Doe <[e-mail]>',
-            'date': start_date + datetime.timedelta(hours=12),
-            'added': [
-                FileNode(b'executable_0o100755', b'mode_755', mode=0o100755),
-                FileNode(b'executable_0o100500', b'mode_500', mode=0o100500),
-                FileNode(b'not_executable', b'mode_644', mode=0o100644),
+            "message": "Initial Commit",
+            "author": "Joe Doe <[e-mail]>",
+            "date": start_date + datetime.timedelta(hours=12),
+            "added": [
+                FileNode(b"executable_0o100755", b"mode_755", mode=0o100755),
+                FileNode(b"executable_0o100500", b"mode_500", mode=0o100500),
+                FileNode(b"not_executable", b"mode_644", mode=0o100644),
             ],
         }
         for x in range(5):
             yield {
-                'message': 'Commit %d' % x,
-                'author': 'Joe Doe <[e-mail]>',
-                'date': start_date + datetime.timedelta(hours=12 * x),
-                'added': [
-                    FileNode(b'%d/file_%d.txt' % (x, x), content=b'Foobar %d' % x),
+                "message": "Commit %d" % x,
+                "author": "Joe Doe <[e-mail]>",
+                "date": start_date + datetime.timedelta(hours=12 * x),
+                "added": [
+                    FileNode(b"%d/file_%d.txt" % (x, x), content=b"Foobar %d" % x),
                 ],
             }
 
-    @pytest.mark.parametrize('compressor', ['gz', 'bz2'])
+    @pytest.mark.parametrize("compressor", ["gz", "bz2"])
     def test_archive_tar(self, compressor, tmpdir, tmp_path, d_cache_config):
-
-        archive_node = tmp_path / 'archive-node'
+        archive_node = tmp_path / "archive-node"
         archive_node.touch()
 
         archive_lnk = self.tip.archive_repo(
-            str(archive_node), kind=f't{compressor}', archive_dir_name='repo', cache_config=d_cache_config)
+            str(archive_node), kind=f"t{compressor}", archive_dir_name="repo", cache_config=d_cache_config
+        )
 
         out_dir = tmpdir
-        out_file = tarfile.open(str(archive_lnk), f'r|{compressor}')
+        out_file = tarfile.open(str(archive_lnk), f"r|{compressor}")
         out_file.extractall(out_dir)
         out_file.close()
 
         for x in range(5):
-            node_path = '%d/file_%d.txt' % (x, x)
-            with open(os.path.join(out_dir, 'repo/' + node_path), 'rb') as f:
+            node_path = "%d/file_%d.txt" % (x, x)
+            with open(os.path.join(out_dir, "repo/" + node_path), "rb") as f:
                 file_content = f.read()
             assert file_content == self.tip.get_node(node_path).content
 
         shutil.rmtree(out_dir)
 
-    @pytest.mark.parametrize('compressor', ['gz', 'bz2'])
+    @pytest.mark.parametrize("compressor", ["gz", "bz2"])
     def test_archive_tar_symlink(self, compressor):
-        pytest.skip('Not supported')
+        pytest.skip("Not supported")
 
-    @pytest.mark.parametrize('compressor', ['gz', 'bz2'])
+    @pytest.mark.parametrize("compressor", ["gz", "bz2"])
     def test_archive_tar_file_modes(self, compressor, tmpdir, tmp_path, d_cache_config):
-        archive_node = tmp_path / 'archive-node'
+        archive_node = tmp_path / "archive-node"
         archive_node.touch()
 
         archive_lnk = self.tip.archive_repo(
-            str(archive_node), kind='t{}'.format(compressor), archive_dir_name='repo', cache_config=d_cache_config)
+            str(archive_node), kind="t{}".format(compressor), archive_dir_name="repo", cache_config=d_cache_config
+        )
 
         out_dir = tmpdir
-        out_file = tarfile.open(str(archive_lnk), 'r|{}'.format(compressor))
+        out_file = tarfile.open(str(archive_lnk), "r|{}".format(compressor))
         out_file.extractall(out_dir)
         out_file.close()
 
         def dest(inp):
             return os.path.join(out_dir, "repo/" + inp)
 
-        assert oct(os.stat(dest('not_executable')).st_mode) == '0o100644'
+        assert oct(os.stat(dest("not_executable")).st_mode) == "0o100644"
 
     def test_archive_zip(self, tmp_path, d_cache_config):
-        archive_node = tmp_path / 'archive-node'
-        archive_node.touch()
-
-        archive_lnk = self.tip.archive_repo(str(archive_node), kind='zip',
-                                            archive_dir_name='repo', cache_config=d_cache_config)
-        zip_file = zipfile.ZipFile(str(archive_lnk))
-
-        for x in range(5):
-            node_path = '%d/file_%d.txt' % (x, x)
-            data = zip_file.read(f'repo/{node_path}')
-
-            decompressed = io.BytesIO()
-            decompressed.write(data)
-            assert decompressed.getvalue() == \
-                self.tip.get_node(node_path).content
-            decompressed.close()
-
-    def test_archive_zip_with_metadata(self, tmp_path, d_cache_config):
-        archive_node = tmp_path / 'archive-node'
+        archive_node = tmp_path / "archive-node"
         archive_node.touch()
 
         archive_lnk = self.tip.archive_repo(
-            str(archive_node), kind='zip',
-            archive_dir_name='repo', write_metadata=True, cache_config=d_cache_config)
+            str(archive_node), kind="zip", archive_dir_name="repo", cache_config=d_cache_config
+        )
+        zip_file = zipfile.ZipFile(str(archive_lnk))
+
+        for x in range(5):
+            node_path = "%d/file_%d.txt" % (x, x)
+            data = zip_file.read(f"repo/{node_path}")
+
+            decompressed = io.BytesIO()
+            decompressed.write(data)
+            assert decompressed.getvalue() == self.tip.get_node(node_path).content
+            decompressed.close()
+
+    def test_archive_zip_with_metadata(self, tmp_path, d_cache_config):
+        archive_node = tmp_path / "archive-node"
+        archive_node.touch()
+
+        archive_lnk = self.tip.archive_repo(
+            str(archive_node), kind="zip", archive_dir_name="repo", write_metadata=True, cache_config=d_cache_config
+        )
 
         zip_file = zipfile.ZipFile(str(archive_lnk))
-        metafile = zip_file.read('repo/.archival.txt')
+        metafile = zip_file.read("repo/.archival.txt")
 
         raw_id = ascii_bytes(self.tip.raw_id)
-        assert b'commit_id:%b' % raw_id in metafile
+        assert b"commit_id:%b" % raw_id in metafile
 
         for x in range(5):
-            node_path = '%d/file_%d.txt' % (x, x)
-            data = zip_file.read(f'repo/{node_path}')
+            node_path = "%d/file_%d.txt" % (x, x)
+            data = zip_file.read(f"repo/{node_path}")
             decompressed = io.BytesIO()
             decompressed.write(data)
-            assert decompressed.getvalue() == \
-                self.tip.get_node(node_path).content
+            assert decompressed.getvalue() == self.tip.get_node(node_path).content
             decompressed.close()
 
     def test_archive_wrong_kind(self, tmp_path, d_cache_config):
-        archive_node = tmp_path / 'archive-node'
+        archive_node = tmp_path / "archive-node"
         archive_node.touch()
 
         with pytest.raises(ImproperArchiveTypeError):
-            self.tip.archive_repo(str(archive_node), kind='wrong kind', cache_config=d_cache_config)
+            self.tip.archive_repo(str(archive_node), kind="wrong kind", cache_config=d_cache_config)
 
 
 @pytest.fixture()
@@ -167,8 +165,8 b' def base_commit():'
     """
     commit = base.BaseCommit()
     commit.repository = mock.Mock()
-    commit.repository.name = 'fake_repo'
-    commit.short_id = 'fake_id'
+    commit.repository.name = "fake_repo"
+    commit.short_id = "fake_id"
     return commit
 
 
@@ -180,19 +178,17 b' def test_validate_archive_prefix_enforce'
 def test_validate_archive_prefix_empty_prefix(base_commit):
     # TODO: johbo: Should raise a ValueError here.
     with pytest.raises(VCSError):
-        base_commit._validate_archive_prefix('')
+        base_commit._validate_archive_prefix("")
 
 
 def test_validate_archive_prefix_with_leading_slash(base_commit):
     # TODO: johbo: Should raise a ValueError here.
     with pytest.raises(VCSError):
-        base_commit._validate_archive_prefix('/any')
+        base_commit._validate_archive_prefix("/any")
 
 
 def test_validate_archive_prefix_falls_back_to_repository_name(base_commit):
     prefix = base_commit._validate_archive_prefix(None)
-    expected_prefix = base_commit._ARCHIVE_PREFIX_TEMPLATE.format(
-        repo_name='fake_repo',
-        short_id='fake_id')
+    expected_prefix = base_commit._ARCHIVE_PREFIX_TEMPLATE.format(repo_name="fake_repo", short_id="fake_id")
     assert isinstance(prefix, str)
     assert prefix == expected_prefix

rhodecode/tests/vcs/test_branches.py

@@ -64,18 +64,14 b' class TestBranches(BackendTestMixin):'
     def test_new_head(self):
         tip = self.repo.get_commit()
 
-        self.imc.add(
-            FileNode(b"docs/index.txt", content=b"Documentation\n")
-        )
+        self.imc.add(FileNode(b"docs/index.txt", content=b"Documentation\n"))
         foobar_tip = self.imc.commit(
             message="New branch: foobar",
             author="joe <[e-mail]>",
             branch="foobar",
             parents=[tip],
         )
-        self.imc.change(
-            FileNode(b"docs/index.txt", content=b"Documentation\nand more...\n")
-        )
+        self.imc.change(FileNode(b"docs/index.txt", content=b"Documentation\nand more...\n"))
         assert foobar_tip.branch == "foobar"
         newtip = self.imc.commit(
             message="At foobar_tip branch",
@@ -96,21 +92,15 b' class TestBranches(BackendTestMixin):'
     @pytest.mark.backends("git", "hg")
     def test_branch_with_slash_in_name(self):
         self.imc.add(FileNode(b"extrafile", content=b"Some data\n"))
-        self.imc.commit(
-            "Branch with a slash!", author="joe <[e-mail]>", branch="issue/123"
-        )
+        self.imc.commit("Branch with a slash!", author="joe <[e-mail]>", branch="issue/123")
         assert "issue/123" in self.repo.branches
 
     @pytest.mark.backends("git", "hg")
     def test_branch_with_slash_in_name_and_similar_without(self):
         self.imc.add(FileNode(b"extrafile", content=b"Some data\n"))
-        self.imc.commit(
-            "Branch with a slash!", author="joe <[e-mail]>", branch="issue/123"
-        )
+        self.imc.commit("Branch with a slash!", author="joe <[e-mail]>", branch="issue/123")
         self.imc.add(FileNode(b"extrafile II", content=b"Some data\n"))
-        self.imc.commit(
-            "Branch without a slash...", author="joe <[e-mail]>", branch="123"
-        )
+        self.imc.commit("Branch without a slash...", author="joe <[e-mail]>", branch="123")
         assert "issue/123" in self.repo.branches
         assert "123" in self.repo.branches
 

rhodecode/tests/vcs/test_client_http.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -28,9 +27,7 b' from rhodecode.lib.vcs import client_htt'
 
 
 def is_new_connection(logger, level, message):
-    return (
-        logger == 'requests.packages.urllib3.connectionpool' and
-        message.startswith('Starting new HTTP'))
+    return logger == "requests.packages.urllib3.connectionpool" and message.startswith("Starting new HTTP")
 
 
 @pytest.fixture()
@@ -54,7 +51,7 b' def stub_fail_session():'
     """
     session = mock.Mock()
     post = session.post()
-    post.content = msgpack.packb({'error': '500'})
+    post.content = msgpack.packb({"error": "500"})
     post.status_code = 500
 
     session.reset_mock()
@@ -89,44 +86,37 b' def test_uses_persistent_http_connection'
         for x in range(5):
             remote_call(normal=True, closed=False)
 
-    new_connections = [
-        r for r in caplog.record_tuples if is_new_connection(*r)]
+    new_connections = [r for r in caplog.record_tuples if is_new_connection(*r)]
     assert len(new_connections) <= 1
 
 
 def test_repo_maker_uses_session_for_classmethods(stub_session_factory):
-    repo_maker = client_http.RemoteVCSMaker(
-        'server_and_port', 'endpoint', 'test_dummy_scm', stub_session_factory)
+    repo_maker = client_http.RemoteVCSMaker("server_and_port", "endpoint", "test_dummy_scm", stub_session_factory)
     repo_maker.example_call()
-    stub_session_factory().post.assert_called_with(
-        'http://server_and_port/endpoint', data=mock.ANY)
+    stub_session_factory().post.assert_called_with("http://server_and_port/endpoint", data=mock.ANY)
 
 
-def test_repo_maker_uses_session_for_instance_methods(
-        stub_session_factory, config):
-    repo_maker = client_http.RemoteVCSMaker(
-        'server_and_port', 'endpoint', 'test_dummy_scm', stub_session_factory)
-    repo = repo_maker('stub_path', 'stub_repo_id', config)
+def test_repo_maker_uses_session_for_instance_methods(stub_session_factory, config):
+    repo_maker = client_http.RemoteVCSMaker("server_and_port", "endpoint", "test_dummy_scm", stub_session_factory)
+    repo = repo_maker("stub_path", "stub_repo_id", config)
     repo.example_call()
-    stub_session_factory().post.assert_called_with(
-        'http://server_and_port/endpoint', data=mock.ANY)
+    stub_session_factory().post.assert_called_with("http://server_and_port/endpoint", data=mock.ANY)
 
 
[e-mail]('rhodecode.lib.vcs.client_http.ThreadlocalSessionFactory')
[e-mail]('rhodecode.lib.vcs.connection')
-def test_connect_passes_in_the_same_session(
-        connection, session_factory_class, stub_session):
[e-mail]("rhodecode.lib.vcs.client_http.ThreadlocalSessionFactory")
[e-mail]("rhodecode.lib.vcs.connection")
+def test_connect_passes_in_the_same_session(connection, session_factory_class, stub_session):
     session_factory = session_factory_class.return_value
     session_factory.return_value = stub_session
 
-    vcs.connect_http('server_and_port')
+    vcs.connect_http("server_and_port")
 
 
-def test_repo_maker_uses_session_that_throws_error(
-        stub_session_failing_factory, config):
+def test_repo_maker_uses_session_that_throws_error(stub_session_failing_factory, config):
     repo_maker = client_http.RemoteVCSMaker(
-        'server_and_port', 'endpoint', 'test_dummy_scm', stub_session_failing_factory)
-    repo = repo_maker('stub_path', 'stub_repo_id', config)
+        "server_and_port", "endpoint", "test_dummy_scm", stub_session_failing_factory
+    )
+    repo = repo_maker("stub_path", "stub_repo_id", config)
 
     with pytest.raises(exceptions.HttpVCSCommunicationError):
         repo.example_call()

rhodecode/tests/vcs/test_commits.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -23,27 +22,31 b' import time'
 import pytest
 
 from rhodecode.lib.str_utils import safe_bytes
-from rhodecode.lib.vcs.backends.base import (
-    CollectionGenerator, FILEMODE_DEFAULT, EmptyCommit)
+from rhodecode.lib.vcs.backends.base import CollectionGenerator, FILEMODE_DEFAULT, EmptyCommit
 from rhodecode.lib.vcs.exceptions import (
-    BranchDoesNotExistError, CommitDoesNotExistError,
-    RepositoryError, EmptyRepositoryError)
+    BranchDoesNotExistError,
+    CommitDoesNotExistError,
+    RepositoryError,
+    EmptyRepositoryError,
+)
 from rhodecode.lib.vcs.nodes import (
-    FileNode, AddedFileNodesGenerator,
-    ChangedFileNodesGenerator, RemovedFileNodesGenerator)
+    FileNode,
+    AddedFileNodesGenerator,
+    ChangedFileNodesGenerator,
+    RemovedFileNodesGenerator,
+)
 from rhodecode.tests import get_new_dir
 from rhodecode.tests.vcs.conftest import BackendTestMixin
 
 
 class TestBaseChangeset(object):
-
     def test_is_deprecated(self):
         from rhodecode.lib.vcs.backends.base import BaseChangeset
+
         pytest.deprecated_call(BaseChangeset)
 
 
 class TestEmptyCommit(object):
-
     def test_branch_without_alias_returns_none(self):
         commit = EmptyCommit()
         assert commit.branch is None
@@ -58,29 +61,28 b' class TestCommitsInNonEmptyRepo(BackendT'
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in range(5):
             yield {
-                'message': 'Commit %d' % x,
-                'author': 'Joe Doe <[e-mail]>',
-                'date': start_date + datetime.timedelta(hours=12 * x),
-                'added': [
-                    FileNode(b'file_%d.txt' % x,
-                             content=b'Foobar %d' % x),
+                "message": "Commit %d" % x,
+                "author": "Joe Doe <[e-mail]>",
+                "date": start_date + datetime.timedelta(hours=12 * x),
+                "added": [
+                    FileNode(b"file_%d.txt" % x, content=b"Foobar %d" % x),
                 ],
             }
 
     def test_walk_returns_empty_list_in_case_of_file(self):
-        result = list(self.tip.walk('file_0.txt'))
+        result = list(self.tip.walk("file_0.txt"))
         assert result == []
 
     @pytest.mark.backends("git", "hg")
     def test_new_branch(self):
-        self.imc.add(FileNode(b'docs/index.txt', content=b'Documentation\n'))
+        self.imc.add(FileNode(b"docs/index.txt", content=b"Documentation\n"))
         foobar_tip = self.imc.commit(
-            message='New branch: foobar',
-            author='joe <[e-mail]>',
-            branch='foobar',
+            message="New branch: foobar",
+            author="joe <[e-mail]>",
+            branch="foobar",
         )
-        assert 'foobar' in self.repo.branches
-        assert foobar_tip.branch == 'foobar'
+        assert "foobar" in self.repo.branches
+        assert foobar_tip.branch == "foobar"
         # 'foobar' should be the only branch that contains the new commit
         branch = list(self.repo.branches.values())
         assert branch[0] != branch[1]
@@ -89,18 +91,14 b' class TestCommitsInNonEmptyRepo(BackendT'
     def test_new_head_in_default_branch(self):
         tip = self.repo.get_commit()
 
-        self.imc.add(
-            FileNode(b"docs/index.txt", content=b"Documentation\n")
-        )
+        self.imc.add(FileNode(b"docs/index.txt", content=b"Documentation\n"))
         foobar_tip = self.imc.commit(
             message="New branch: foobar",
             author="joe <[e-mail]>",
             branch="foobar",
             parents=[tip],
         )
-        self.imc.change(
-            FileNode(b"docs/index.txt", content=b"Documentation\nand more...\n")
-        )
+        self.imc.change(FileNode(b"docs/index.txt", content=b"Documentation\nand more...\n"))
         assert foobar_tip.branch == "foobar"
         newtip = self.imc.commit(
             message="At foobar_tip branch",
@@ -132,51 +130,55 b' class TestCommitsInNonEmptyRepo(BackendT'
         :return:
         """
         DEFAULT_BRANCH = self.repo.DEFAULT_BRANCH_NAME
-        TEST_BRANCH = 'docs'
+        TEST_BRANCH = "docs"
         org_tip = self.repo.get_commit()
 
-        self.imc.add(FileNode(b'readme.txt', content=b'Document\n'))
+        self.imc.add(FileNode(b"readme.txt", content=b"Document\n"))
         initial = self.imc.commit(
-            message='Initial commit',
-            author='joe <[e-mail]>',
+            message="Initial commit",
+            author="joe <[e-mail]>",
             parents=[org_tip],
-            branch=DEFAULT_BRANCH,)
+            branch=DEFAULT_BRANCH,
+        )
 
-        self.imc.add(FileNode(b'newdoc.txt', content=b'foobar\n'))
+        self.imc.add(FileNode(b"newdoc.txt", content=b"foobar\n"))
         docs_branch_commit1 = self.imc.commit(
-            message='New branch: docs',
-            author='joe <[e-mail]>',
+            message="New branch: docs",
+            author="joe <[e-mail]>",
             parents=[initial],
-            branch=TEST_BRANCH,)
+            branch=TEST_BRANCH,
+        )
 
-        self.imc.add(FileNode(b'newdoc2.txt', content=b'foobar2\n'))
+        self.imc.add(FileNode(b"newdoc2.txt", content=b"foobar2\n"))
         docs_branch_commit2 = self.imc.commit(
-            message='New branch: docs2',
-            author='joe <[e-mail]>',
+            message="New branch: docs2",
+            author="joe <[e-mail]>",
             parents=[docs_branch_commit1],
-            branch=TEST_BRANCH,)
+            branch=TEST_BRANCH,
+        )
 
-        self.imc.add(FileNode(b'newfile', content=b'hello world\n'))
+        self.imc.add(FileNode(b"newfile", content=b"hello world\n"))
         self.imc.commit(
-            message='Back in default branch',
-            author='joe <[e-mail]>',
+            message="Back in default branch",
+            author="joe <[e-mail]>",
             parents=[initial],
-            branch=DEFAULT_BRANCH,)
+            branch=DEFAULT_BRANCH,
+        )
 
         default_branch_commits = self.repo.get_commits(branch_name=DEFAULT_BRANCH)
         assert docs_branch_commit1 not in list(default_branch_commits)
         assert docs_branch_commit2 not in list(default_branch_commits)
 
         docs_branch_commits = self.repo.get_commits(
-            start_id=self.repo.commit_ids[0], end_id=self.repo.commit_ids[-1],
-            branch_name=TEST_BRANCH)
+            start_id=self.repo.commit_ids[0], end_id=self.repo.commit_ids[-1], branch_name=TEST_BRANCH
+        )
         assert docs_branch_commit1 in list(docs_branch_commits)
         assert docs_branch_commit2 in list(docs_branch_commits)
 
     @pytest.mark.backends("svn")
     def test_get_commits_respects_branch_name_svn(self, vcsbackend_svn):
-        repo = vcsbackend_svn['svn-simple-layout']
-        commits = repo.get_commits(branch_name='trunk')
+        repo = vcsbackend_svn["svn-simple-layout"]
+        commits = repo.get_commits(branch_name="trunk")
         commit_indexes = [c.idx for c in commits]
         assert commit_indexes == [1, 2, 3, 7, 12, 15]
 
@@ -214,13 +216,10 b' class TestCommits(BackendTestMixin):'
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in range(5):
             yield {
-                'message': 'Commit %d' % x,
-                'author': 'Joe Doe <[e-mail]>',
-                'date': start_date + datetime.timedelta(hours=12 * x),
-                'added': [
-                    FileNode(b'file_%d.txt' % x,
-                             content=b'Foobar %d' % x)
-                ],
+                "message": "Commit %d" % x,
+                "author": "Joe Doe <[e-mail]>",
+                "date": start_date + datetime.timedelta(hours=12 * x),
+                "added": [FileNode(b"file_%d.txt" % x, content=b"Foobar %d" % x)],
             }
 
     def test_simple(self):
@@ -231,11 +230,11 b' class TestCommits(BackendTestMixin):'
         tip = self.repo.get_commit()
         # json.dumps(tip) uses .__json__() method
         data = tip.__json__()
-        assert 'branch' in data
-        assert data['revision']
+        assert "branch" in data
+        assert data["revision"]
 
     def test_retrieve_tip(self):
-        tip = self.repo.get_commit('tip')
+        tip = self.repo.get_commit("tip")
         assert tip == self.repo.get_commit()
 
     def test_invalid(self):
@@ -259,34 +258,34 b' class TestCommits(BackendTestMixin):'
 
     def test_size(self):
         tip = self.repo.get_commit()
-        size = 5 * len('Foobar N')  # Size of 5 files
+        size = 5 * len("Foobar N")  # Size of 5 files
         assert tip.size == size
 
     def test_size_at_commit(self):
         tip = self.repo.get_commit()
-        size = 5 * len('Foobar N')  # Size of 5 files
+        size = 5 * len("Foobar N")  # Size of 5 files
         assert self.repo.size_at_commit(tip.raw_id) == size
 
     def test_size_at_first_commit(self):
         commit = self.repo[0]
-        size = len('Foobar N')  # Size of 1 file
+        size = len("Foobar N")  # Size of 1 file
         assert self.repo.size_at_commit(commit.raw_id) == size
 
     def test_author(self):
         tip = self.repo.get_commit()
-        assert_text_equal(tip.author, 'Joe Doe <[e-mail]>')
+        assert_text_equal(tip.author, "Joe Doe <[e-mail]>")
 
     def test_author_name(self):
         tip = self.repo.get_commit()
-        assert_text_equal(tip.author_name, 'Joe Doe')
+        assert_text_equal(tip.author_name, "Joe Doe")
 
     def test_author_email(self):
         tip = self.repo.get_commit()
-        assert_text_equal(tip.author_email, '[e-mail]')
+        assert_text_equal(tip.author_email, "[e-mail]")
 
     def test_message(self):
         tip = self.repo.get_commit()
-        assert_text_equal(tip.message, 'Commit 4')
+        assert_text_equal(tip.message, "Commit 4")
 
     def test_diff(self):
         tip = self.repo.get_commit()
@@ -296,7 +295,7 b' class TestCommits(BackendTestMixin):'
     def test_prev(self):
         tip = self.repo.get_commit()
         prev_commit = tip.prev()
-        assert prev_commit.message == 'Commit 3'
+        assert prev_commit.message == "Commit 3"
 
     def test_prev_raises_on_first_commit(self):
         commit = self.repo.get_commit(commit_idx=0)
@@ -311,7 +310,7 b' class TestCommits(BackendTestMixin):'
     def test_next(self):
         commit = self.repo.get_commit(commit_idx=2)
         next_commit = commit.next()
-        assert next_commit.message == 'Commit 3'
+        assert next_commit.message == "Commit 3"
 
     def test_next_raises_on_tip(self):
         commit = self.repo.get_commit()
@@ -320,36 +319,36 b' class TestCommits(BackendTestMixin):'
 
     def test_get_path_commit(self):
         commit = self.repo.get_commit()
-        commit.get_path_commit('file_4.txt')
-        assert commit.message == 'Commit 4'
+        commit.get_path_commit("file_4.txt")
+        assert commit.message == "Commit 4"
 
     def test_get_filenodes_generator(self):
         tip = self.repo.get_commit()
         filepaths = [node.path for node in tip.get_filenodes_generator()]
-        assert filepaths == ['file_%d.txt' % x for x in range(5)]
+        assert filepaths == ["file_%d.txt" % x for x in range(5)]
 
     def test_get_file_annotate(self):
         file_added_commit = self.repo.get_commit(commit_idx=3)
-        annotations = list(file_added_commit.get_file_annotate('file_3.txt'))
+        annotations = list(file_added_commit.get_file_annotate("file_3.txt"))
 
         line_no, commit_id, commit_loader, line = annotations[0]
 
         assert line_no == 1
         assert commit_id == file_added_commit.raw_id
         assert commit_loader() == file_added_commit
-        assert b'Foobar 3' in line
+        assert b"Foobar 3" in line
 
     def test_get_file_annotate_does_not_exist(self):
         file_added_commit = self.repo.get_commit(commit_idx=2)
         # TODO: Should use a specific exception class here?
         with pytest.raises(Exception):
-            list(file_added_commit.get_file_annotate('file_3.txt'))
+            list(file_added_commit.get_file_annotate("file_3.txt"))
 
     def test_get_file_annotate_tip(self):
         tip = self.repo.get_commit()
         commit = self.repo.get_commit(commit_idx=3)
-        expected_values = list(commit.get_file_annotate('file_3.txt'))
-        annotations = list(tip.get_file_annotate('file_3.txt'))
+        expected_values = list(commit.get_file_annotate("file_3.txt"))
+        annotations = list(tip.get_file_annotate("file_3.txt"))
 
         # Note: Skip index 2 because the loader function is not the same
         for idx in (0, 1, 3):
@@ -398,7 +397,7 b' class TestCommits(BackendTestMixin):'
         repo = self.Backend(repo_path, create=True)
 
         with pytest.raises(EmptyRepositoryError):
-            list(repo.get_commits(start_id='foobar'))
+            list(repo.get_commits(start_id="foobar"))
 
     def test_get_commits_respects_hidden(self):
         commits = self.repo.get_commits(show_hidden=True)
@@ -424,8 +423,7 b' class TestCommits(BackendTestMixin):'
 
     def test_get_commits_respects_start_date_with_branch(self):
         start_date = datetime.datetime(2010, 1, 2)
-        commits = self.repo.get_commits(
-            start_date=start_date, branch_name=self.repo.DEFAULT_BRANCH_NAME)
+        commits = self.repo.get_commits(start_date=start_date, branch_name=self.repo.DEFAULT_BRANCH_NAME)
         assert isinstance(commits, CollectionGenerator)
         # Should be 4 commits after 2010-01-02 00:00:00
         assert len(commits) == 4
@@ -435,8 +433,7 b' class TestCommits(BackendTestMixin):'
     def test_get_commits_respects_start_date_and_end_date(self):
         start_date = datetime.datetime(2010, 1, 2)
         end_date = datetime.datetime(2010, 1, 3)
-        commits = self.repo.get_commits(start_date=start_date,
-                                        end_date=end_date)
+        commits = self.repo.get_commits(start_date=start_date, end_date=end_date)
         assert isinstance(commits, CollectionGenerator)
         assert len(commits) == 2
         for c in commits:
@@ -459,23 +456,22 b' class TestCommits(BackendTestMixin):'
         assert list(commit_ids) == list(reversed(self.repo.commit_ids))
 
     def test_get_commits_slice_generator(self):
-        commits = self.repo.get_commits(
-            branch_name=self.repo.DEFAULT_BRANCH_NAME)
+        commits = self.repo.get_commits(branch_name=self.repo.DEFAULT_BRANCH_NAME)
         assert isinstance(commits, CollectionGenerator)
         commit_slice = list(commits[1:3])
         assert len(commit_slice) == 2
 
     def test_get_commits_raise_commitdoesnotexist_for_wrong_start(self):
         with pytest.raises(CommitDoesNotExistError):
-            list(self.repo.get_commits(start_id='foobar'))
+            list(self.repo.get_commits(start_id="foobar"))
 
     def test_get_commits_raise_commitdoesnotexist_for_wrong_end(self):
         with pytest.raises(CommitDoesNotExistError):
-            list(self.repo.get_commits(end_id='foobar'))
+            list(self.repo.get_commits(end_id="foobar"))
 
     def test_get_commits_raise_branchdoesnotexist_for_wrong_branch_name(self):
         with pytest.raises(BranchDoesNotExistError):
-            list(self.repo.get_commits(branch_name='foobar'))
+            list(self.repo.get_commits(branch_name="foobar"))
 
     def test_get_commits_raise_repositoryerror_for_wrong_start_end(self):
         start_id = self.repo.commit_ids[-1]
@@ -498,13 +494,16 b' class TestCommits(BackendTestMixin):'
         assert commit1 is not None
         assert commit2 is not None
         assert 1 != commit1
-        assert 'string' != commit1
+        assert "string" != commit1
 
 
[e-mail]("filename, expected", [
-    ("README.rst", False),
-    ("README", True),
-])
[e-mail](
+    "filename, expected",
+    [
+        ("README.rst", False),
+        ("README", True),
+    ],
+)
 def test_commit_is_link(vcsbackend, filename, expected):
     commit = vcsbackend.repo.get_commit()
     link_status = commit.is_link(filename)
@@ -519,75 +518,74 b' class TestCommitsChanges(BackendTestMixi'
     def _get_commits(cls):
         return [
             {
-                'message': 'Initial',
-                'author': 'Joe Doe <[e-mail]>',
-                'date': datetime.datetime(2010, 1, 1, 20),
-                'added': [
-                    FileNode(b'foo/bar', content=b'foo'),
-                    FileNode(safe_bytes('foo/bał'), content=b'foo'),
-                    FileNode(b'foobar', content=b'foo'),
-                    FileNode(b'qwe', content=b'foo'),
+                "message": "Initial",
+                "author": "Joe Doe <[e-mail]>",
+                "date": datetime.datetime(2010, 1, 1, 20),
+                "added": [
+                    FileNode(b"foo/bar", content=b"foo"),
+                    FileNode(safe_bytes("foo/bał"), content=b"foo"),
+                    FileNode(b"foobar", content=b"foo"),
+                    FileNode(b"qwe", content=b"foo"),
                 ],
             },
             {
-                'message': 'Massive changes',
-                'author': 'Joe Doe <[e-mail]>',
-                'date': datetime.datetime(2010, 1, 1, 22),
-                'added': [FileNode(b'fallout', content=b'War never changes')],
-                'changed': [
-                    FileNode(b'foo/bar', content=b'baz'),
-                    FileNode(b'foobar', content=b'baz'),
+                "message": "Massive changes",
+                "author": "Joe Doe <[e-mail]>",
+                "date": datetime.datetime(2010, 1, 1, 22),
+                "added": [FileNode(b"fallout", content=b"War never changes")],
+                "changed": [
+                    FileNode(b"foo/bar", content=b"baz"),
+                    FileNode(b"foobar", content=b"baz"),
                 ],
-                'removed': [FileNode(b'qwe')],
+                "removed": [FileNode(b"qwe")],
             },
         ]
 
     def test_initial_commit(self, local_dt_to_utc):
         commit = self.repo.get_commit(commit_idx=0)
         assert set(commit.added) == {
-            commit.get_node('foo/bar'),
-            commit.get_node('foo/bał'),
-            commit.get_node('foobar'),
-            commit.get_node('qwe')
+            commit.get_node("foo/bar"),
+            commit.get_node("foo/bał"),
+            commit.get_node("foobar"),
+            commit.get_node("qwe"),
         }
         assert set(commit.changed) == set()
         assert set(commit.removed) == set()
-        assert set(commit.affected_files) == {'foo/bar', 'foo/bał', 'foobar', 'qwe'}
-        assert commit.date == local_dt_to_utc(
-            datetime.datetime(2010, 1, 1, 20, 0))
+        assert set(commit.affected_files) == {"foo/bar", "foo/bał", "foobar", "qwe"}
+        assert commit.date == local_dt_to_utc(datetime.datetime(2010, 1, 1, 20, 0))
 
     def test_head_added(self):
         commit = self.repo.get_commit()
         assert isinstance(commit.added, AddedFileNodesGenerator)
-        assert set(commit.added) == {commit.get_node('fallout')}
+        assert set(commit.added) == {commit.get_node("fallout")}
         assert isinstance(commit.changed, ChangedFileNodesGenerator)
-        assert set(commit.changed) == {commit.get_node('foo/bar'), commit.get_node('foobar')}
+        assert set(commit.changed) == {commit.get_node("foo/bar"), commit.get_node("foobar")}
         assert isinstance(commit.removed, RemovedFileNodesGenerator)
         assert len(commit.removed) == 1
-        assert list(commit.removed)[0].path == 'qwe'
+        assert list(commit.removed)[0].path == "qwe"
 
     def test_get_filemode(self):
         commit = self.repo.get_commit()
-        assert FILEMODE_DEFAULT == commit.get_file_mode('foo/bar')
+        assert FILEMODE_DEFAULT == commit.get_file_mode("foo/bar")
 
     def test_get_filemode_non_ascii(self):
         commit = self.repo.get_commit()
-        assert FILEMODE_DEFAULT == commit.get_file_mode('foo/bał')
-        assert FILEMODE_DEFAULT == commit.get_file_mode('foo/bał')
+        assert FILEMODE_DEFAULT == commit.get_file_mode("foo/bał")
+        assert FILEMODE_DEFAULT == commit.get_file_mode("foo/bał")
 
     def test_get_path_history(self):
         commit = self.repo.get_commit()
-        history = commit.get_path_history('foo/bar')
+        history = commit.get_path_history("foo/bar")
         assert len(history) == 2
 
     def test_get_path_history_with_limit(self):
         commit = self.repo.get_commit()
-        history = commit.get_path_history('foo/bar', limit=1)
+        history = commit.get_path_history("foo/bar", limit=1)
         assert len(history) == 1
 
     def test_get_path_history_first_commit(self):
         commit = self.repo[0]
-        history = commit.get_path_history('foo/bar')
+        history = commit.get_path_history("foo/bar")
         assert len(history) == 1
 
 

rhodecode/tests/vcs/test_config.py

@@ -1,4 +1,3 b''
-
 # Copyright (C) 2010-2023 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
@@ -21,14 +20,17 b' import pytest'
 
 
 def test_get_existing_value(config):
-    value = config.get('section-a', 'a-1')
-    assert value == 'value-a-1'
+    value = config.get("section-a", "a-1")
+    assert value == "value-a-1"
 
 
[e-mail]('section, option', [
-    ('section-a', 'does-not-exist'),
-    ('does-not-exist', 'does-not-exist'),
-])
[e-mail](
+    "section, option",
+    [
+        ("section-a", "does-not-exist"),
+        ("does-not-exist", "does-not-exist"),
+    ],
+)
 def test_get_unset_value_returns_none(config, section, option):
     value = config.get(section, option)
     assert value is None
@@ -41,11 +43,11 b' def test_allows_to_create_a_copy(config)'
 
 def test_changes_in_the_copy_dont_affect_the_original(config):
     clone = config.copy()
-    clone.set('section-a', 'a-2', 'value-a-2')
-    assert set(config.serialize()) == {('section-a', 'a-1', 'value-a-1')}
+    clone.set("section-a", "a-2", "value-a-2")
+    assert set(config.serialize()) == {("section-a", "a-1", "value-a-1")}
 
 
 def test_changes_in_the_original_dont_affect_the_copy(config):
     clone = config.copy()
-    config.set('section-a', 'a-2', 'value-a-2')
-    assert set(clone.serialize()) == {('section-a', 'a-1', 'value-a-1')}
+    config.set("section-a", "a-2", "value-a-2")
+    assert set(clone.serialize()) == {("section-a", "a-1", "value-a-1")}