more usage of fixture tools

in tests

rhodecode/tests/__init__.py

@@ -60,8 +60,7 b' log = logging.getLogger(__name__)'
     'TEST_USER_REGULAR2_PASS', 'TEST_USER_REGULAR2_EMAIL', 'TEST_HG_REPO',
     'TEST_HG_REPO_CLONE', 'TEST_HG_REPO_PULL', 'TEST_GIT_REPO',
     'TEST_GIT_REPO_CLONE', 'TEST_GIT_REPO_PULL', 'HG_REMOTE_REPO',
-    'GIT_REMOTE_REPO', 'SCM_TESTS', '_get_repo_create_params',
-    '_get_group_create_params'
+    'GIT_REMOTE_REPO', 'SCM_TESTS',
 ]
 
 # Invoke websetup with the current config file
@@ -174,37 +173,3 b' class TestController(TestCase):'
             msg = u'msg `%s` not found in session flash: got `%s` instead' % (
                       msg, response.session['flash'][0][1])
             self.fail(safe_str(msg))
-
-
-## HELPERS ##
-
-def _get_repo_create_params(**custom):
-    defs = {
-        'repo_name': None,
-        'repo_type': 'hg',
-        'clone_uri': '',
-        'repo_group': '',
-        'repo_description': 'DESC',
-        'repo_private': False,
-        'repo_landing_rev': 'tip'
-    }
-    defs.update(custom)
-    if 'repo_name_full' not in custom:
-        defs.update({'repo_name_full': defs['repo_name']})
-
-    return defs
-
-
-def _get_group_create_params(**custom):
-    defs = dict(
-        group_name=None,
-        group_description='DESC',
-        group_parent_id=None,
-        perms_updates=[],
-        perms_new=[],
-        enable_locking=False,
-        recursive=False
-    )
-    defs.update(custom)
-
-    return defs

rhodecode/tests/api/api_base.py

@@ -3,6 +3,7 b' import random'
 import mock
 
 from rhodecode.tests import *
+from rhodecode.tests.fixture import Fixture
 from rhodecode.lib.compat import json
 from rhodecode.lib.auth import AuthUser
 from rhodecode.model.user import UserModel
@@ -12,7 +13,11 b' from rhodecode.model.meta import Session'
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.db import Repository
 
+
 API_URL = '/_admin/api'
+TEST_USER_GROUP = 'test_users_group'
+
+fixture = Fixture()
 
 
 def _build_data(apikey, method, **kw):
@@ -43,9 +48,7 b' def api_call(test_obj, params):'
     return response
 
 
-TEST_USER_GROUP = 'test_users_group'
-
-
+## helpers
 def make_users_group(name=TEST_USER_GROUP):
     gr = UserGroupModel().create(name=name)
     UserGroupModel().add_user_to_group(users_group=gr,
@@ -59,32 +62,6 b' def destroy_users_group(name=TEST_USER_G'
     Session().commit()
 
 
-def create_repo(repo_name, repo_type, owner=None):
-    # create new repo
-    form_data = _get_repo_create_params(
-                    repo_name_full=repo_name,
-                    repo_description='description %s' % repo_name,
-                )
-    cur_user = UserModel().get_by_username(owner or TEST_USER_ADMIN_LOGIN)
-    r = RepoModel().create(form_data, cur_user)
-    Session().commit()
-    return r
-
-
-def create_fork(fork_name, fork_type, fork_of):
-    fork = RepoModel(Session())._get_repo(fork_of)
-    r = create_repo(fork_name, fork_type)
-    r.fork = fork
-    Session().add(r)
-    Session().commit()
-    return r
-
-
-def destroy_repo(repo_name):
-    RepoModel().delete(repo_name)
-    Session().commit()
-
-
 class BaseTestApi(object):
     REPO = None
     REPO_TYPE = None
@@ -248,7 +225,7 b' class BaseTestApi(object):'
         pass
 
 #        repo_name = 'test_pull'
-#        r = create_repo(repo_name, self.REPO_TYPE)
+#        r = fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)
 #        r.clone_uri = TEST_self.REPO
 #        Session.add(r)
 #        Session.commit()
@@ -261,7 +238,7 b' class BaseTestApi(object):'
 #        expected = 'Pulled from `%s`' % repo_name
 #        self._compare_ok(id_, expected, given=response.body)
 #
-#        destroy_repo(repo_name)
+#        fixture.destroy_repo(repo_name)
 
     def test_api_pull_error(self):
         id_, params = _build_data(self.apikey, 'pull',
@@ -317,7 +294,8 b' class BaseTestApi(object):'
 
     def test_api_lock_repo_lock_aquire_by_non_admin(self):
         repo_name = 'api_delete_me'
-        create_repo(repo_name, self.REPO_TYPE, owner=self.TEST_USER_LOGIN)
+        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,
+                            cur_user=self.TEST_USER_LOGIN)
         try:
             id_, params = _build_data(self.apikey_regular, 'lock',
                                       repoid=repo_name,
@@ -327,11 +305,12 b' class BaseTestApi(object):'
                        % (self.TEST_USER_LOGIN, repo_name, True))
             self._compare_ok(id_, expected, given=response.body)
         finally:
-            destroy_repo(repo_name)
+            fixture.destroy_repo(repo_name)
 
     def test_api_lock_repo_lock_aquire_non_admin_with_userid(self):
         repo_name = 'api_delete_me'
-        create_repo(repo_name, self.REPO_TYPE, owner=self.TEST_USER_LOGIN)
+        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,
+                            cur_user=self.TEST_USER_LOGIN)
         try:
             id_, params = _build_data(self.apikey_regular, 'lock',
                                       userid=TEST_USER_ADMIN_LOGIN,
@@ -341,7 +320,7 b' class BaseTestApi(object):'
             expected = 'userid is not the same as your user'
             self._compare_error(id_, expected, given=response.body)
         finally:
-            destroy_repo(repo_name)
+            fixture.destroy_repo(repo_name)
 
     def test_api_lock_repo_lock_aquire_non_admin_not_his_repo(self):
         id_, params = _build_data(self.apikey_regular, 'lock',
@@ -770,7 +749,7 b' class BaseTestApi(object):'
         }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
-        destroy_repo(repo_name)
+        fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_unknown_owner(self):
         repo_name = 'api-repo'
@@ -800,7 +779,7 b' class BaseTestApi(object):'
         }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
-        destroy_repo(repo_name)
+        fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_by_non_admin(self):
         repo_name = 'api-repo'
@@ -818,7 +797,7 b' class BaseTestApi(object):'
         }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
-        destroy_repo(repo_name)
+        fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_by_non_admin_specify_owner(self):
         repo_name = 'api-repo'
@@ -832,7 +811,7 b' class BaseTestApi(object):'
 
         expected = 'Only RhodeCode admin can specify `owner` param'
         self._compare_error(id_, expected, given=response.body)
-        destroy_repo(repo_name)
+        fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_exists(self):
         repo_name = self.REPO
@@ -859,7 +838,7 b' class BaseTestApi(object):'
 
     def test_api_delete_repo(self):
         repo_name = 'api_delete_me'
-        create_repo(repo_name, self.REPO_TYPE)
+        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)
 
         id_, params = _build_data(self.apikey, 'delete_repo',
                                   repoid=repo_name,)
@@ -874,7 +853,8 b' class BaseTestApi(object):'
 
     def test_api_delete_repo_by_non_admin(self):
         repo_name = 'api_delete_me'
-        create_repo(repo_name, self.REPO_TYPE, owner=self.TEST_USER_LOGIN)
+        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE,
+                            cur_user=self.TEST_USER_LOGIN)
         try:
             id_, params = _build_data(self.apikey_regular, 'delete_repo',
                                       repoid=repo_name,)
@@ -887,11 +867,11 b' class BaseTestApi(object):'
             expected = ret
             self._compare_ok(id_, expected, given=response.body)
         finally:
-            destroy_repo(repo_name)
+            fixture.destroy_repo(repo_name)
 
     def test_api_delete_repo_by_non_admin_no_permission(self):
         repo_name = 'api_delete_me'
-        create_repo(repo_name, self.REPO_TYPE)
+        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)
         try:
             id_, params = _build_data(self.apikey_regular, 'delete_repo',
                                       repoid=repo_name,)
@@ -899,11 +879,11 b' class BaseTestApi(object):'
             expected = 'repository `%s` does not exist' % (repo_name)
             self._compare_error(id_, expected, given=response.body)
         finally:
-            destroy_repo(repo_name)
+            fixture.destroy_repo(repo_name)
 
     def test_api_delete_repo_exception_occurred(self):
         repo_name = 'api_delete_me'
-        create_repo(repo_name, self.REPO_TYPE)
+        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)
         try:
             with mock.patch.object(RepoModel, 'delete', crash):
                 id_, params = _build_data(self.apikey, 'delete_repo',
@@ -913,7 +893,7 b' class BaseTestApi(object):'
                 expected = 'failed to delete repository `%s`' % repo_name
                 self._compare_error(id_, expected, given=response.body)
         finally:
-            destroy_repo(repo_name)
+            fixture.destroy_repo(repo_name)
 
     def test_api_fork_repo(self):
         fork_name = 'api-repo-fork'
@@ -931,7 +911,7 b' class BaseTestApi(object):'
         }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
-        destroy_repo(fork_name)
+        fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_non_admin(self):
         fork_name = 'api-repo-fork'
@@ -948,7 +928,7 b' class BaseTestApi(object):'
         }
         expected = ret
         self._compare_ok(id_, expected, given=response.body)
-        destroy_repo(fork_name)
+        fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_non_admin_specify_owner(self):
         fork_name = 'api-repo-fork'
@@ -960,7 +940,7 b' class BaseTestApi(object):'
         response = api_call(self, params)
         expected = 'Only RhodeCode admin can specify `owner` param'
         self._compare_error(id_, expected, given=response.body)
-        destroy_repo(fork_name)
+        fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_non_admin_no_permission_to_fork(self):
         RepoModel().grant_user_permission(repo=self.REPO,
@@ -974,7 +954,7 b' class BaseTestApi(object):'
         response = api_call(self, params)
         expected = 'repository `%s` does not exist' % (self.REPO)
         self._compare_error(id_, expected, given=response.body)
-        destroy_repo(fork_name)
+        fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_unknown_owner(self):
         fork_name = 'api-repo-fork'
@@ -990,7 +970,7 b' class BaseTestApi(object):'
 
     def test_api_fork_repo_fork_exists(self):
         fork_name = 'api-repo-fork'
-        create_fork(fork_name, self.REPO_TYPE, self.REPO)
+        fixture.create_fork(self.REPO, fork_name)
 
         try:
             fork_name = 'api-repo-fork'
@@ -1005,7 +985,7 b' class BaseTestApi(object):'
             expected = "fork `%s` already exist" % fork_name
             self._compare_error(id_, expected, given=response.body)
         finally:
-            destroy_repo(fork_name)
+            fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_repo_exists(self):
         fork_name = self.REPO

rhodecode/tests/fixture.py

@@ -1,12 +1,11 b''
 """
 Helpers for fixture generation
 """
-import os
-import unittest
 from rhodecode.tests import *
-from rhodecode.model.db import Repository, User
+from rhodecode.model.db import Repository, User, RepoGroup
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
+from rhodecode.model.repos_group import ReposGroupModel
 
 
 class Fixture(object):
@@ -14,30 +13,90 b' class Fixture(object):'
     def __init__(self):
         pass
 
+    def _get_repo_create_params(self, **custom):
+        defs = dict(
+            repo_name=None,
+            repo_type='hg',
+            clone_uri='',
+            repo_group='',
+            repo_description='DESC',
+            repo_private=False,
+            repo_landing_rev='tip'
+        )
+        defs.update(custom)
+        if 'repo_name_full' not in custom:
+            defs.update({'repo_name_full': defs['repo_name']})
+
+        return defs
+
+    def _get_group_create_params(self, **custom):
+        defs = dict(
+            group_name=None,
+            group_description='DESC',
+            group_parent_id=None,
+            perms_updates=[],
+            perms_new=[],
+            enable_locking=False,
+            recursive=False
+        )
+        defs.update(custom)
+
+        return defs
+
     def create_repo(self, name, **kwargs):
-        form_data = _get_repo_create_params(repo_name=name, **kwargs)
-        cur_user = User.get_by_username(TEST_USER_ADMIN_LOGIN)
+        if 'skip_if_exists' in kwargs:
+            del kwargs['skip_if_exists']
+            r = Repository.get_by_repo_name(name)
+            if r:
+                return r
+
+        if isinstance(kwargs.get('repos_group'), RepoGroup):
+            #TODO: rename the repos_group !
+            kwargs['repo_group'] = kwargs['repos_group'].group_id
+            del kwargs['repos_group']
+
+        form_data = self._get_repo_create_params(repo_name=name, **kwargs)
+        cur_user = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)
         RepoModel().create(form_data, cur_user)
+        Session().commit()
         return Repository.get_by_repo_name(name)
 
     def create_fork(self, repo_to_fork, fork_name, **kwargs):
         repo_to_fork = Repository.get_by_repo_name(repo_to_fork)
-        vcs_type = repo_to_fork.repo_type
+
+        form_data = self._get_repo_create_params(repo_name=fork_name,
+                                            fork_parent_id=repo_to_fork,
+                                            repo_type=repo_to_fork.repo_type,
+                                            **kwargs)
+        form_data['update_after_clone'] = False
+
+        #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_rev']
+
+        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)
+        assert r
+        return r
 
-        form_data = dict(
-            repo_name=fork_name,
-            repo_name_full=fork_name,
-            repo_group=None,
-            repo_type=vcs_type,
-            description='',
-            private=False,
-            copy_permissions=False,
-            landing_rev='tip',
-            update_after_clone=False,
-            fork_parent_id=repo_to_fork,
-        )
-        cur_user = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)
-        RepoModel().create_fork(form_data, cur_user=cur_user)
+    def destroy_repo(self, repo_name):
+        RepoModel().delete(repo_name)
+        Session().commit()
 
+    def create_group(self, name, **kwargs):
+        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)
+        gr = ReposGroupModel().create(group_name=form_data['group_name'],
+                                 group_description=form_data['group_name'],
+                                 owner=owner, parent=form_data['group_parent_id'])
         Session().commit()
-        return Repository.get_by_repo_name(fork_name)
+        gr = RepoGroup.get_by_group_name(gr.group_name)
+        return gr

rhodecode/tests/functional/test_admin_repos.py

@@ -10,6 +10,9 b' from rhodecode.tests import *'
 from rhodecode.model.repos_group import ReposGroupModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.meta import Session
+from rhodecode.tests.fixture import Fixture
+
+fixture = Fixture()
 
 
 def _get_permission_for_user(user, repo):
@@ -36,7 +39,7 b' class TestAdminReposController(TestContr'
         repo_name = NEW_HG_REPO
         description = 'description for newly created repo'
         response = self.app.post(url('repos'),
-                        _get_repo_create_params(repo_private=False,
+                        fixture._get_repo_create_params(repo_private=False,
                                                 repo_name=repo_name,
                                                 repo_description=description))
         self.checkSessionFlash(response,
@@ -70,7 +73,7 b' class TestAdminReposController(TestContr'
         description_unicode = description.decode('utf8')
         private = False
         response = self.app.post(url('repos'),
-                        _get_repo_create_params(repo_private=False,
+                        fixture._get_repo_create_params(repo_private=False,
                                                 repo_name=repo_name,
                                                 repo_description=description))
         self.checkSessionFlash(response,
@@ -108,7 +111,7 b' class TestAdminReposController(TestContr'
         repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])
         description = 'description for newly created repo'
         response = self.app.post(url('repos'),
-                        _get_repo_create_params(repo_private=False,
+                        fixture._get_repo_create_params(repo_private=False,
                                                 repo_name=repo_name,
                                                 repo_description=description,
                                                 repo_group=gr.group_id,))
@@ -146,7 +149,7 b' class TestAdminReposController(TestContr'
         description = 'description for newly created repo'
 
         response = self.app.post(url('repos'),
-                        _get_repo_create_params(repo_private=False,
+                        fixture._get_repo_create_params(repo_private=False,
                                                 repo_type='git',
                                                 repo_name=repo_name,
                                                 repo_description=description))
@@ -181,7 +184,7 b' class TestAdminReposController(TestContr'
         description_unicode = description.decode('utf8')
         private = False
         response = self.app.post(url('repos'),
-                        _get_repo_create_params(repo_private=False,
+                        fixture._get_repo_create_params(repo_private=False,
                                                 repo_type='git',
                                                 repo_name=repo_name,
                                                 repo_description=description))
@@ -220,7 +223,7 b' class TestAdminReposController(TestContr'
         repo_name = 'vcs_test_new_to_delete'
         description = 'description for newly created repo'
         response = self.app.post(url('repos'),
-                        _get_repo_create_params(repo_private=False,
+                        fixture._get_repo_create_params(repo_private=False,
                                                 repo_type='hg',
                                                 repo_name=repo_name,
                                                 repo_description=description))
@@ -267,7 +270,7 b' class TestAdminReposController(TestContr'
         description = 'description for newly created repo'
         private = False
         response = self.app.post(url('repos'),
-                        _get_repo_create_params(repo_private=False,
+                        fixture._get_repo_create_params(repo_private=False,
                                                 repo_type='git',
                                                 repo_name=repo_name,
                                                 repo_description=description))
@@ -337,7 +340,7 b' class TestAdminReposController(TestContr'
         self.assertEqual(Repository.get_by_repo_name(HG_REPO).private, False)
 
         response = self.app.put(url('repo', repo_name=HG_REPO),
-                        _get_repo_create_params(repo_private=1,
+                        fixture._get_repo_create_params(repo_private=1,
                                                 repo_name=HG_REPO,
                                                 user=TEST_USER_ADMIN_LOGIN))
         self.checkSessionFlash(response,
@@ -350,7 +353,7 b' class TestAdminReposController(TestContr'
         self.assertEqual(perm[0].permission.permission_name, 'repository.none')
 
         response = self.app.put(url('repo', repo_name=HG_REPO),
-                        _get_repo_create_params(repo_private=False,
+                        fixture._get_repo_create_params(repo_private=False,
                                                 repo_name=HG_REPO,
                                                 user=TEST_USER_ADMIN_LOGIN))
         self.checkSessionFlash(response,

rhodecode/tests/functional/test_compare.py

@@ -52,10 +52,9 b' class TestCompareController(TestControll'
 
     def test_compare_forks_on_branch_extra_commits_hg(self):
         self.log_user()
-        repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',
-                                        description='diff-test',
-                                        owner=TEST_USER_ADMIN_LOGIN)
-        Session().commit()
+        repo1 = fixture.create_repo('one', repo_type='hg',
+                                    repo_description='diff-test',
+                                    cur_user=TEST_USER_ADMIN_LOGIN)
         self.r1_id = repo1.repo_id
         #commit something !
         cs0 = _commit_change(repo1.repo_name, filename='file1', content='line1\n',
@@ -102,10 +101,10 b' class TestCompareController(TestControll'
     def test_compare_forks_on_branch_extra_commits_origin_has_incomming_hg(self):
         self.log_user()
 
-        repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',
-                                        description='diff-test',
-                                        owner=TEST_USER_ADMIN_LOGIN)
-        Session().commit()
+        repo1 = fixture.create_repo('one', repo_type='hg',
+                                    repo_description='diff-test',
+                                    cur_user=TEST_USER_ADMIN_LOGIN)
+
         self.r1_id = repo1.repo_id
 
         #commit something !
@@ -168,10 +167,9 b' class TestCompareController(TestControll'
         #make repo1, and cs1+cs2
         self.log_user()
 
-        repo1 = RepoModel().create_repo(repo_name='repo1', repo_type='hg',
-                                        description='diff-test',
-                                        owner=TEST_USER_ADMIN_LOGIN)
-        Session().commit()
+        repo1 = fixture.create_repo('repo1', repo_type='hg',
+                                    repo_description='diff-test',
+                                    cur_user=TEST_USER_ADMIN_LOGIN)
         self.r1_id = repo1.repo_id
 
         #commit something !
@@ -196,7 +194,7 b' class TestCompareController(TestControll'
         response = self.app.get(url(controller='compare', action='index',
                                     repo_name=repo2.repo_name,
                                     org_ref_type="rev",
-                                    org_ref=cs1.short_id, # parent of cs2, in repo2
+                                    org_ref=cs1.short_id,  # parent of cs2, in repo2
                                     other_repo=repo1.repo_name,
                                     other_ref_type="rev",
                                     other_ref=cs4.short_id,
@@ -230,10 +228,9 b' class TestCompareController(TestControll'
 #
         #make repo1, and cs1+cs2
         self.log_user()
-        repo1 = RepoModel().create_repo(repo_name='repo1', repo_type='hg',
-                                        description='diff-test',
-                                        owner=TEST_USER_ADMIN_LOGIN)
-        Session().commit()
+        repo1 = fixture.create_repo('repo1', repo_type='hg',
+                                    repo_description='diff-test',
+                                    cur_user=TEST_USER_ADMIN_LOGIN)
         self.r1_id = repo1.repo_id
 
         #commit something !
@@ -278,9 +275,6 b' class TestCompareController(TestControll'
         response.mustcontain("""#C--826e8142e6ba">file1</a>""")
 
     def test_compare_cherry_pick_changeset_mixed_branches(self):
-        """
-
-        """
         pass
         #TODO write this tastecase
 
@@ -316,11 +310,10 b' class TestCompareController(TestControll'
     def test_org_repo_new_commits_after_forking_simple_diff(self):
         self.log_user()
 
-        repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',
-                                        description='diff-test',
-                                        owner=TEST_USER_ADMIN_LOGIN)
+        repo1 = fixture.create_repo('one', repo_type='hg',
+                                    repo_description='diff-test',
+                                    cur_user=TEST_USER_ADMIN_LOGIN)
 
-        Session().commit()
         self.r1_id = repo1.repo_id
         r1_name = repo1.repo_name
 
@@ -336,10 +329,11 b' class TestCompareController(TestControll'
         Session().commit()
         self.assertEqual(repo1.scm_instance.revisions, [cs0.raw_id])
         #fork the repo1
-        repo2 = RepoModel().create_repo(repo_name='one-fork', repo_type='hg',
-                                description='compare-test',
-                                clone_uri=repo1.repo_full_path,
-                                owner=TEST_USER_ADMIN_LOGIN, fork_of='one')
+        repo2 = fixture.create_repo('one-fork', repo_type='hg',
+                                    repo_description='diff-test',
+                                    cur_user=TEST_USER_ADMIN_LOGIN,
+                                    clone_uri=repo1.repo_full_path,
+                                    fork_of='one')
         Session().commit()
         self.assertEqual(repo2.scm_instance.revisions, [cs0.raw_id])
         self.r2_id = repo2.repo_id

rhodecode/tests/functional/test_home.py

@@ -1,13 +1,15 b''
 import time
 from rhodecode.tests import *
+from rhodecode.tests.fixture import Fixture
 from rhodecode.model.meta import Session
-from rhodecode.model.db import User, RhodeCodeSetting, Repository
-from rhodecode.lib.utils import set_rhodecode_config
-from rhodecode.tests.models.common import _make_repo, _make_group
+from rhodecode.model.db import User, Repository
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repos_group import ReposGroupModel
 
 
+fixture = Fixture()
+
+
 class TestHomeController(TestController):
 
     def test_index(self):
@@ -75,18 +77,19 b' merge" class="tooltip" href="/vcs_test_h'
 
         try:
             response = self.app.get(url(controller='home', action='index'))
-            response.mustcontain("""var data = {"totalRecords": %s""" % len(Repository.getAll()))
+            response.mustcontain("""var data = {"totalRecords": %s"""
+                                 % len(Repository.getAll()))
         finally:
             self._set_l_dash(False)
 
     def test_index_page_on_groups(self):
         self.log_user()
-        _make_repo(name='gr1/repo_in_group', repos_group=_make_group('gr1'))
-        Session().commit()
+        gr = fixture.create_group('gr1')
+        fixture.create_repo(name='gr1/repo_in_group', repos_group=gr)
         response = self.app.get(url('repos_group_home', group_name='gr1'))
 
         try:
-            response.mustcontain("""gr1/repo_in_group""")
+            response.mustcontain("gr1/repo_in_group")
         finally:
             RepoModel().delete('gr1/repo_in_group')
             ReposGroupModel().delete(repos_group='gr1', force_delete=True)
@@ -95,8 +98,8 b' merge" class="tooltip" href="/vcs_test_h'
     def test_index_page_on_groups_with_lightweight_dashboard(self):
         self.log_user()
         self._set_l_dash(True)
-        _make_repo(name='gr1/repo_in_group', repos_group=_make_group('gr1'))
-        Session().commit()
+        fixture.create_repo(name='gr1/repo_in_group',
+                            repos_group=fixture.create_group('gr1'))
         response = self.app.get(url('repos_group_home', group_name='gr1'))
 
         try:

rhodecode/tests/functional/test_summary.py

@@ -1,10 +1,12 b''
 from rhodecode.tests import *
+from rhodecode.tests.fixture import Fixture
 from rhodecode.model.db import Repository
 from rhodecode.lib.utils import invalidate_cache
 from rhodecode.model.repo import RepoModel
-from rhodecode.tests.models.common import _make_repo
 from rhodecode.model.meta import Session
 
+fixture = Fixture()
+
 
 class TestSummaryController(TestController):
 
@@ -87,14 +89,13 b' class TestSummaryController(TestControll'
 
     def test_index_by_repo_having_id_path_in_name_hg(self):
         self.log_user()
-        _make_repo(name='repo_1')
-        Session().commit()
+        fixture.create_repo(name='repo_1')
         response = self.app.get(url(controller='summary',
                                     action='index',
                                     repo_name='repo_1'))
 
         try:
-            response.mustcontain("""repo_1""")
+            response.mustcontain("repo_1")
         finally:
             RepoModel().delete(Repository.get_by_repo_name('repo_1'))
             Session().commit()

rhodecode/tests/models/common.py

@@ -2,7 +2,7 b' import os'
 import unittest
 import functools
 from rhodecode.tests import *
-
+from rhodecode.tests.fixture import Fixture
 
 from rhodecode.model.repos_group import ReposGroupModel
 from rhodecode.model.repo import RepoModel
@@ -13,23 +13,7 b' from rhodecode.lib.auth import AuthUser'
 from rhodecode.model.meta import Session
 
 
-def _make_group(path, desc='desc', parent_id=None,
-                 skip_if_exists=False):
-
-    gr = RepoGroup.get_by_group_name(path)
-    if gr and skip_if_exists:
-        return gr
-    if isinstance(parent_id, RepoGroup):
-        parent_id = parent_id.group_id
-    gr = ReposGroupModel().create(path, desc, TEST_USER_ADMIN_LOGIN, parent_id)
-    return gr
-
-
-def _make_repo(name, repos_group=None, repo_type='hg', private=False):
-    return RepoModel().create_repo(name, repo_type, 'desc',
-                                   TEST_USER_ADMIN_LOGIN,
-                                   repos_group=repos_group,
-                                   private=private)
+fixture = Fixture()
 
 
 def _destroy_project_tree(test_u1_id):
@@ -75,19 +59,19 b' def _create_project_tree():'
         username=u'test_u1', password=u'qweqwe',
         email=u'[e-mail]', firstname=u'test_u1', lastname=u'test_u1'
     )
-    g0 = _make_group('g0')
-    g0_1 = _make_group('g0_1', parent_id=g0)
-    g0_1_1 = _make_group('g0_1_1', parent_id=g0_1)
-    g0_1_1_r1 = _make_repo('g0/g0_1/g0_1_1/g0_1_1_r1', repos_group=g0_1_1)
-    g0_1_1_r2 = _make_repo('g0/g0_1/g0_1_1/g0_1_1_r2', repos_group=g0_1_1)
-    g0_1_r1 = _make_repo('g0/g0_1/g0_1_r1', repos_group=g0_1)
-    g0_2 = _make_group('g0_2', parent_id=g0)
-    g0_2_r1 = _make_repo('g0/g0_2/g0_2_r1', repos_group=g0_2)
-    g0_2_r2 = _make_repo('g0/g0_2/g0_2_r2', repos_group=g0_2)
-    g0_3 = _make_group('g0_3', parent_id=g0)
-    g0_3_r1 = _make_repo('g0/g0_3/g0_3_r1', repos_group=g0_3)
-    g0_3_r2_private = _make_repo('g0/g0_3/g0_3_r1_private', repos_group=g0_3,
-                                 private=True)
+    g0 = fixture.create_group('g0')
+    g0_1 = fixture.create_group('g0_1', group_parent_id=g0)
+    g0_1_1 = fixture.create_group('g0_1_1', group_parent_id=g0_1)
+    g0_1_1_r1 = fixture.create_repo('g0/g0_1/g0_1_1/g0_1_1_r1', repos_group=g0_1_1)
+    g0_1_1_r2 = fixture.create_repo('g0/g0_1/g0_1_1/g0_1_1_r2', repos_group=g0_1_1)
+    g0_1_r1 = fixture.create_repo('g0/g0_1/g0_1_r1', repos_group=g0_1)
+    g0_2 = fixture.create_group('g0_2', group_parent_id=g0)
+    g0_2_r1 = fixture.create_repo('g0/g0_2/g0_2_r1', repos_group=g0_2)
+    g0_2_r2 = fixture.create_repo('g0/g0_2/g0_2_r2', repos_group=g0_2)
+    g0_3 = fixture.create_group('g0_3', group_parent_id=g0)
+    g0_3_r1 = fixture.create_repo('g0/g0_3/g0_3_r1', repos_group=g0_3)
+    g0_3_r2_private = fixture.create_repo('g0/g0_3/g0_3_r1_private',
+                                          repos_group=g0_3, repo_private=True)
     return test_u1
 
 

rhodecode/tests/models/test_permissions.py

@@ -1,7 +1,7 b''
 import os
 import unittest
 from rhodecode.tests import *
-from rhodecode.tests.models.common import _make_group
+from rhodecode.tests.fixture import Fixture
 from rhodecode.model.repos_group import ReposGroupModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.db import RepoGroup, User, UserGroupRepoGroupToPerm
@@ -10,7 +10,9 b' from rhodecode.model.user import UserMod'
 from rhodecode.model.meta import Session
 from rhodecode.model.users_group import UserGroupModel
 from rhodecode.lib.auth import AuthUser
-from rhodecode.tests.api.api_base import create_repo
+
+
+fixture = Fixture()
 
 
 class TestPermissions(unittest.TestCase):
@@ -94,8 +96,8 b' class TestPermissions(unittest.TestCase)'
                          perms['repositories'][HG_REPO])
 
     def test_default_group_perms(self):
-        self.g1 = _make_group('test1', skip_if_exists=True)
-        self.g2 = _make_group('test2', skip_if_exists=True)
+        self.g1 = fixture.create_group('test1', skip_if_exists=True)
+        self.g2 = fixture.create_group('test2', skip_if_exists=True)
         u1_auth = AuthUser(user_id=self.u1.user_id)
         perms = {
             'repositories_groups': {u'test1': 'group.read', u'test2': 'group.read'},
@@ -108,8 +110,8 b' class TestPermissions(unittest.TestCase)'
                          perms['repositories_groups'])
 
     def test_default_admin_group_perms(self):
-        self.g1 = _make_group('test1', skip_if_exists=True)
-        self.g2 = _make_group('test2', skip_if_exists=True)
+        self.g1 = fixture.create_group('test1', skip_if_exists=True)
+        self.g2 = fixture.create_group('test2', skip_if_exists=True)
         a1_auth = AuthUser(user_id=self.a1.user_id)
         perms = {
             'repositories_groups': {u'test1': 'group.admin', u'test2': 'group.admin'},
@@ -216,9 +218,8 b' class TestPermissions(unittest.TestCase)'
                          perms['repositories_groups'])
 
     def test_repo_in_group_permissions(self):
-        self.g1 = _make_group('group1', skip_if_exists=True)
-        self.g2 = _make_group('group2', skip_if_exists=True)
-        Session().commit()
+        self.g1 = fixture.create_group('group1', skip_if_exists=True)
+        self.g2 = fixture.create_group('group2', skip_if_exists=True)
         # both perms should be read !
         u1_auth = AuthUser(user_id=self.u1.user_id)
         self.assertEqual(u1_auth.permissions['repositories_groups'],
@@ -246,14 +247,10 b' class TestPermissions(unittest.TestCase)'
 
         # add repo to group
         name = RepoGroup.url_sep().join([self.g1.group_name, 'test_perm'])
-        self.test_repo = RepoModel().create_repo(
-            repo_name=name,
-            repo_type='hg',
-            description='',
-            repos_group=self.g1,
-            owner=self.u1,
-        )
-        Session().commit()
+        self.test_repo = fixture.create_repo(name=name,
+                                             repo_type='hg',
+                                             repos_group=self.g1,
+                                             cur_user=self.u1,)
 
         u1_auth = AuthUser(user_id=self.u1.user_id)
         self.assertEqual(u1_auth.permissions['repositories_groups'],
@@ -287,8 +284,7 b' class TestPermissions(unittest.TestCase)'
 
     def test_repo_group_user_as_user_group_member(self):
         # create Group1
-        self.g1 = _make_group('group1', skip_if_exists=True)
-        Session().commit()
+        self.g1 = fixture.create_group('group1', skip_if_exists=True)
         a1_auth = AuthUser(user_id=self.anon.user_id)
 
         self.assertEqual(a1_auth.permissions['repositories_groups'],
@@ -429,12 +425,10 b' class TestPermissions(unittest.TestCase)'
 
     def test_owner_permissions_doesnot_get_overwritten_by_group(self):
         #create repo as USER,
-        self.test_repo = repo = RepoModel().create_repo(repo_name='myownrepo',
-                                repo_type='hg',
-                                description='desc',
-                                owner=self.u1)
+        self.test_repo = fixture.create_repo(name='myownrepo',
+                                             repo_type='hg',
+                                             cur_user=self.u1)
 
-        Session().commit()
         #he has permissions of admin as owner
         u1_auth = AuthUser(user_id=self.u1.user_id)
         self.assertEqual(u1_auth.permissions['repositories']['myownrepo'],
@@ -443,7 +437,8 b' class TestPermissions(unittest.TestCase)'
         self.ug1 = UserGroupModel().create('G1')
         # add user to group
         UserGroupModel().add_user_to_group(self.ug1, self.u1)
-        RepoModel().grant_users_group_permission(repo, group_name=self.ug1,
+        RepoModel().grant_users_group_permission(self.test_repo,
+                                                 group_name=self.ug1,
                                                  perm='repository.none')
 
         Session().commit()
@@ -453,18 +448,16 b' class TestPermissions(unittest.TestCase)'
 
     def test_owner_permissions_doesnot_get_overwritten_by_others(self):
         #create repo as USER,
-        self.test_repo = repo = RepoModel().create_repo(repo_name='myownrepo',
-                                repo_type='hg',
-                                description='desc',
-                                owner=self.u1)
+        self.test_repo = fixture.create_repo(name='myownrepo',
+                                             repo_type='hg',
+                                             cur_user=self.u1)
 
-        Session().commit()
         #he has permissions of admin as owner
         u1_auth = AuthUser(user_id=self.u1.user_id)
         self.assertEqual(u1_auth.permissions['repositories']['myownrepo'],
                          'repository.admin')
         #set his permission as user, he should still be admin
-        RepoModel().grant_user_permission(repo, user=self.u1,
+        RepoModel().grant_user_permission(self.test_repo, user=self.u1,
                                           perm='repository.none')
         Session().commit()
         u1_auth = AuthUser(user_id=self.u1.user_id)

rhodecode/tests/models/test_repos_groups.py

@@ -1,43 +1,29 b''
 import os
 import unittest
+from sqlalchemy.exc import IntegrityError
+
 from rhodecode.tests import *
+from rhodecode.tests.fixture import Fixture
 
 from rhodecode.model.repos_group import ReposGroupModel
 from rhodecode.model.repo import RepoModel
-from rhodecode.model.db import RepoGroup, User
+from rhodecode.model.db import RepoGroup
 from rhodecode.model.meta import Session
-from sqlalchemy.exc import IntegrityError
 
 
-def _make_group(path, desc='desc', parent_id=None,
-                 skip_if_exists=False):
-
-    gr = RepoGroup.get_by_group_name(path)
-    if gr and skip_if_exists:
-        return gr
-    if isinstance(parent_id, RepoGroup):
-        parent_id = parent_id.group_id
-    gr = ReposGroupModel().create(path, desc, TEST_USER_ADMIN_LOGIN, parent_id)
-    return gr
+fixture = Fixture()
 
 
 def _update_group(id_, group_name, desc='desc', parent_id=None):
-    form_data = _get_group_create_params(group_name=group_name,
-                                         group_desc=desc,
-                                         group_parent_id=parent_id)
+    form_data = fixture._get_group_create_params(group_name=group_name,
+                                                 group_desc=desc,
+                                                 group_parent_id=parent_id)
     gr = ReposGroupModel().update(id_, form_data)
     return gr
 
 
-def _make_repo(name, **kwargs):
-    form_data = _get_repo_create_params(repo_name=name, **kwargs)
-    cur_user = User.get_by_username(TEST_USER_ADMIN_LOGIN)
-    r = RepoModel().create(form_data, cur_user)
-    return r
-
-
 def _update_repo(name, **kwargs):
-    form_data = _get_repo_create_params(**kwargs)
+    form_data = fixture._get_repo_create_params(**kwargs)
     if not 'repo_name' in kwargs:
         form_data['repo_name'] = name
     if not 'perms_new' in kwargs:
@@ -51,12 +37,9 b' def _update_repo(name, **kwargs):'
 class TestReposGroups(unittest.TestCase):
 
     def setUp(self):
-        self.g1 = _make_group('test1', skip_if_exists=True)
-        Session().commit()
-        self.g2 = _make_group('test2', skip_if_exists=True)
-        Session().commit()
-        self.g3 = _make_group('test3', skip_if_exists=True)
-        Session().commit()
+        self.g1 = fixture.create_group('test1', skip_if_exists=True)
+        self.g2 = fixture.create_group('test2', skip_if_exists=True)
+        self.g3 = fixture.create_group('test3', skip_if_exists=True)
 
     def tearDown(self):
         Session.remove()
@@ -76,47 +59,42 b' class TestReposGroups(unittest.TestCase)'
         ReposGroupModel().delete(id_)
 
     def test_create_group(self):
-        g = _make_group('newGroup')
+        g = fixture.create_group('newGroup')
         Session().commit()
         self.assertEqual(g.full_path, 'newGroup')
 
         self.assertTrue(self.__check_path('newGroup'))
 
     def test_create_same_name_group(self):
-        self.assertRaises(IntegrityError, lambda: _make_group('newGroup'))
+        self.assertRaises(IntegrityError, lambda: fixture.create_group('newGroup'))
         Session().rollback()
 
     def test_same_subgroup(self):
-        sg1 = _make_group('sub1', parent_id=self.g1.group_id)
-        Session().commit()
+        sg1 = fixture.create_group('sub1', group_parent_id=self.g1.group_id)
         self.assertEqual(sg1.parent_group, self.g1)
         self.assertEqual(sg1.full_path, 'test1/sub1')
         self.assertTrue(self.__check_path('test1', 'sub1'))
 
-        ssg1 = _make_group('subsub1', parent_id=sg1.group_id)
-        Session().commit()
+        ssg1 = fixture.create_group('subsub1', group_parent_id=sg1.group_id)
         self.assertEqual(ssg1.parent_group, sg1)
         self.assertEqual(ssg1.full_path, 'test1/sub1/subsub1')
         self.assertTrue(self.__check_path('test1', 'sub1', 'subsub1'))
 
     def test_remove_group(self):
-        sg1 = _make_group('deleteme')
-        Session().commit()
+        sg1 = fixture.create_group('deleteme')
         self.__delete_group(sg1.group_id)
 
         self.assertEqual(RepoGroup.get(sg1.group_id), None)
         self.assertFalse(self.__check_path('deteteme'))
 
-        sg1 = _make_group('deleteme', parent_id=self.g1.group_id)
-        Session().commit()
+        sg1 = fixture.create_group('deleteme', group_parent_id=self.g1.group_id)
         self.__delete_group(sg1.group_id)
 
         self.assertEqual(RepoGroup.get(sg1.group_id), None)
         self.assertFalse(self.__check_path('test1', 'deteteme'))
 
     def test_rename_single_group(self):
-        sg1 = _make_group('initial')
-        Session().commit()
+        sg1 = fixture.create_group('initial')
 
         new_sg1 = _update_group(sg1.group_id, 'after')
         self.assertTrue(self.__check_path('after'))
@@ -124,8 +102,7 b' class TestReposGroups(unittest.TestCase)'
 
     def test_update_group_parent(self):
 
-        sg1 = _make_group('initial', parent_id=self.g1.group_id)
-        Session().commit()
+        sg1 = fixture.create_group('initial', group_parent_id=self.g1.group_id)
 
         new_sg1 = _update_group(sg1.group_id, 'after', parent_id=self.g1.group_id)
         self.assertTrue(self.__check_path('test1', 'after'))
@@ -142,12 +119,11 b' class TestReposGroups(unittest.TestCase)'
 
     def test_subgrouping_with_repo(self):
 
-        g1 = _make_group('g1')
-        g2 = _make_group('g2')
-        Session().commit()
+        g1 = fixture.create_group('g1')
+        g2 = fixture.create_group('g2')
         # create new repo
-        r = _make_repo('john')
-        Session().commit()
+        r = fixture.create_repo('john')
+
         self.assertEqual(r.repo_name, 'john')
         # put repo into group
         r = _update_repo('john', repo_group=g1.group_id)
@@ -162,10 +138,8 b' class TestReposGroups(unittest.TestCase)'
                                                                 r.just_name]))
 
     def test_move_to_root(self):
-        g1 = _make_group('t11')
-        Session().commit()
-        g2 = _make_group('t22', parent_id=g1.group_id)
-        Session().commit()
+        g1 = fixture.create_group('t11')
+        g2 = fixture.create_group('t22', group_parent_id=g1.group_id)
 
         self.assertEqual(g2.full_path, 't11/t22')
         self.assertTrue(self.__check_path('t11', 't22'))
@@ -180,15 +154,11 b' class TestReposGroups(unittest.TestCase)'
         self.assertTrue(self.__check_path('g22'))
 
     def test_rename_top_level_group_in_nested_setup(self):
-        g1 = _make_group('L1')
-        Session().commit()
-        g2 = _make_group('L2', parent_id=g1.group_id)
-        Session().commit()
-        g3 = _make_group('L3', parent_id=g2.group_id)
-        Session().commit()
+        g1 = fixture.create_group('L1')
+        g2 = fixture.create_group('L2', group_parent_id=g1.group_id)
+        g3 = fixture.create_group('L3', group_parent_id=g2.group_id)
 
-        r = _make_repo('L1/L2/L3/L3_REPO', repo_group=g3.group_id)
-        Session().commit()
+        r = fixture.create_repo('L1/L2/L3/L3_REPO', repo_group=g3.group_id)
 
         ##rename L1 all groups should be now changed
         _update_group(g1.group_id, 'L1_NEW')
@@ -199,18 +169,12 b' class TestReposGroups(unittest.TestCase)'
         self.assertEqual(r.repo_name,  'L1_NEW/L2/L3/L3_REPO')
 
     def test_change_parent_of_top_level_group_in_nested_setup(self):
-        g1 = _make_group('R1')
-        Session().commit()
-        g2 = _make_group('R2', parent_id=g1.group_id)
-        Session().commit()
-        g3 = _make_group('R3', parent_id=g2.group_id)
-        Session().commit()
+        g1 = fixture.create_group('R1')
+        g2 = fixture.create_group('R2', group_parent_id=g1.group_id)
+        g3 = fixture.create_group('R3', group_parent_id=g2.group_id)
+        g4 = fixture.create_group('R1_NEW')
 
-        g4 = _make_group('R1_NEW')
-        Session().commit()
-
-        r = _make_repo('R1/R2/R3/R3_REPO', repo_group=g3.group_id)
-        Session().commit()
+        r = fixture.create_repo('R1/R2/R3/R3_REPO', repo_group=g3.group_id)
         ##rename L1 all groups should be now changed
         _update_group(g1.group_id, 'R1', parent_id=g4.group_id)
         Session().commit()
@@ -220,18 +184,12 b' class TestReposGroups(unittest.TestCase)'
         self.assertEqual(r.repo_name,  'R1_NEW/R1/R2/R3/R3_REPO')
 
     def test_change_parent_of_top_level_group_in_nested_setup_with_rename(self):
-        g1 = _make_group('X1')
-        Session().commit()
-        g2 = _make_group('X2', parent_id=g1.group_id)
-        Session().commit()
-        g3 = _make_group('X3', parent_id=g2.group_id)
-        Session().commit()
+        g1 = fixture.create_group('X1')
+        g2 = fixture.create_group('X2', group_parent_id=g1.group_id)
+        g3 = fixture.create_group('X3', group_parent_id=g2.group_id)
+        g4 = fixture.create_group('X1_NEW')
 
-        g4 = _make_group('X1_NEW')
-        Session().commit()
-
-        r = _make_repo('X1/X2/X3/X3_REPO', repo_group=g3.group_id)
-        Session().commit()
+        r = fixture.create_repo('X1/X2/X3/X3_REPO', repo_group=g3.group_id)
 
         ##rename L1 all groups should be now changed
         _update_group(g1.group_id, 'X1_PRIM', parent_id=g4.group_id)

rhodecode/tests/models/test_users.py

@@ -14,6 +14,9 b' class TestUser(unittest.TestCase):'
         Session.remove()
         super(TestUser, self).__init__(methodName=methodName)
 
+    def tearDown(self):
+        Session.remove()
+
     def test_create_and_remove(self):
         usr = UserModel().create_or_update(username=u'test_user',
                                            password=u'qweqwe',
@@ -99,6 +102,7 b' class TestUsers(unittest.TestCase):'
 
         UserModel().delete(self.u1)
         Session().commit()
+        Session.remove()
 
     def test_add_perm(self):
         perm = Permission.query().all()[0]

rhodecode/tests/test_validators.py

@@ -12,7 +12,6 b' from rhodecode.model.repos_group import '
 from rhodecode.config.routing import ADMIN_PREFIX
 from rhodecode.model.db import ChangesetStatus, Repository
 from rhodecode.model.changeset_status import ChangesetStatusModel
-from rhodecode.model.comment import ChangesetCommentsModel
 
 
 class TestReposGroups(unittest.TestCase):
@@ -21,7 +20,7 b' class TestReposGroups(unittest.TestCase)'
         pass
 
     def tearDown(self):
-        pass
+        Session.remove()
 
     def test_Message_extractor(self):
         validator = v.ValidUsername()