fix(tests): fixed test logic on creation

rhodecode/api/tests/test_fork_repo.py

@@ -56,14 +56,14 @@ class TestApiForkRepo(object):
     def test_api_fork_repo_into_group(self, backend, user_util):
         source_name = backend["minimal"].repo_name
         repo_group = user_util.create_repo_group()
-        fork_name = "%s/api-repo-fork" % repo_group.group_name
+        fork_name = f"{repo_group.group_name}/api-repo-fork"
         id_, params = build_data(
             self.apikey, "fork_repo", repoid=source_name, fork_name=fork_name, owner=TEST_USER_ADMIN_LOGIN
         )
         response = api_call(self.app, params)
 
         ret = {
-            "msg": "Created fork of `%s` as `%s`" % (source_name, fork_name),
+            "msg": f"Created fork of `{source_name}` as `{fork_name}`",
             "success": True,
             "task": None,
         }
@@ -81,7 +81,7 @@ class TestApiForkRepo(object):
         response = api_call(self.app, params)
 
         expected = {
-            "msg": "Created fork of `%s` as `%s`" % (source_name, fork_name),
+            "msg": f"Created fork of `{source_name}` as `{fork_name}`",
             "success": True,
             "task": None,
         }
@@ -94,12 +94,12 @@ class TestApiForkRepo(object):
         source_name = backend["minimal"].repo_name
         repo_group = user_util.create_repo_group()
         repo_group_name = repo_group.group_name
-        fork_name = "%s/api-repo-fork" % repo_group_name
+        fork_name = f"{repo_group_name}/api-repo-fork"
 
         id_, params = build_data(self.apikey_regular, "fork_repo", repoid=source_name, fork_name=fork_name)
         response = api_call(self.app, params)
 
-        expected = {"repo_group": "Repository group `{}` does not exist".format(repo_group_name)}
+        expected = {"repo_group": f"Repository group `{repo_group_name}` does not exist"}
         try:
             assert_error(id_, expected, given=response.body)
         finally:
@@ -108,7 +108,7 @@ class TestApiForkRepo(object):
     def test_api_fork_repo_non_admin_into_group(self, backend, user_util):
         source_name = backend["minimal"].repo_name
         repo_group = user_util.create_repo_group()
-        fork_name = "%s/api-repo-fork" % repo_group.group_name
+        fork_name = f"{repo_group.group_name}/api-repo-fork"
 
         RepoGroupModel().grant_user_permission(repo_group, self.TEST_USER_LOGIN, "group.admin")
         Session().commit()
@@ -117,7 +117,7 @@ class TestApiForkRepo(object):
         response = api_call(self.app, params)
 
         expected = {
-            "msg": "Created fork of `%s` as `%s`" % (source_name, fork_name),
+            "msg": f"Created fork of `{source_name}` as `{fork_name}`",
             "success": True,
             "task": None,
         }
@@ -142,7 +142,7 @@ class TestApiForkRepo(object):
         fork_name = backend.new_repo_name()
         id_, params = build_data(self.apikey_regular, "fork_repo", repoid=backend.repo_name, fork_name=fork_name)
         response = api_call(self.app, params)
-        expected = "repository `%s` does not exist" % (backend.repo_name)
+        expected = f"repository `{backend.repo_name}` does not exist"
         assert_error(id_, expected, given=response.body)
 
     def test_api_fork_repo_non_admin_no_permission_to_fork_to_root_level(self, backend, user_util):

rhodecode/tests/fixtures/fixture_utils.py

@@ -68,7 +68,7 @@ from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.integration import IntegrationModel
 from rhodecode.integrations import integration_type_registry
 from rhodecode.integrations.types.base import IntegrationTypeBase
-from rhodecode.lib.utils import repo2db_mapper
+from rhodecode.lib.utils import repo2db_mapper, repo_name_slug
 from rhodecode.lib.str_utils import safe_bytes
 from rhodecode.lib.hash_utils import sha1_safe
 from rhodecode.lib.vcs.backends import get_backend
@@ -1132,7 +1132,7 @@ 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, random_suffix=True)
+        self._test_name = self._sanitize_name(test_name)
         self.fixture = Fixture()
         self.repo_group_ids = []
         self.repos_ids = []
@@ -1146,26 +1146,37 @@ class UserUtility(object):
         self.user_group_user_group_permission_ids = []
         self.user_permissions = []
 
-    def _sanitize_name(self, name, random_suffix=True):
-        for char in ["[", "]"]:
-            name = name.replace(char, "-").replace("_", "-").replace(".", "-")
-        if random_suffix:
-            length = 4
-            letters = string.ascii_lowercase
-            random_suffix = "".join(random.choice(letters) for i in range(length)).capitalize()
-            name = random_suffix + name
+    def _sanitize_name(self, name):
+        name = repo_name_slug(name)
         return name
 
-    def create_repo_group(self, owner=TEST_USER_ADMIN_LOGIN, auto_cleanup=True):
+    def _random_suffix(self, length=4):
+        letters = string.ascii_lowercase
+        random_suffix = "".join(random.choice(letters) for i in range(length))
+        return random_suffix
+
+    def create_repo_group(self, owner=TEST_USER_ADMIN_LOGIN, auto_cleanup=True, random_suffix=False):
         group_name = f"{self._test_name}-repogroup-{len(self.repo_group_ids)}"
+        if random_suffix:
+            group_name = self._random_suffix() + group_name
         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):
+    def create_repo(
+        self,
+        owner=TEST_USER_ADMIN_LOGIN,
+        parent=None,
+        auto_cleanup=True,
+        repo_type="hg",
+        bare=False,
+        random_suffix=False,
+    ):
         repo_name = f"{self._test_name}-repository-{len(self.repos_ids)}"
-
+        if random_suffix:
+            repo_name = self._random_suffix() + repo_name
         repository = self.fixture.create_repo(
             repo_name, cur_user=owner, repo_group=parent, repo_type=repo_type, bare=bare
         )