Changeset - 8a86836fad64
Parent rev.
Child rev.
[Not reviewed]
beta
0 12 0
Marcin Kuzminski - 13 years ago 2013-04-01 23:45:25
marcin@python-works.com
more usage of fixture tools
in tests
12 files changed with 248 insertions and 305 deletions:
rhodecode/tests/__init__.py
1
36
rhodecode/tests/api/api_base.py
32
52
rhodecode/tests/fixture.py
80
21
rhodecode/tests/functional/test_admin_repos.py
12
9
rhodecode/tests/functional/test_compare.py
22
28
rhodecode/tests/functional/test_home.py
12
9
rhodecode/tests/functional/test_summary.py
5
4
rhodecode/tests/models/common.py
15
31
rhodecode/tests/models/test_permissions.py
24
31
rhodecode/tests/models/test_repos_groups.py
40
82
rhodecode/tests/models/test_users.py
4
rhodecode/tests/test_validators.py
1
2
0 comments (0 inline, 0 general)
rhodecode/tests/__init__.py
➞
Show inline comments
 
@@ -60,8 +60,7 @@ __all__ = [
 
    '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 @@ 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -3,6 +3,7 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
"""

			




	
	
	
		
 
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 @@ 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -10,6 +10,9 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -52,10 +52,9 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
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 @@ 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 @@ 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
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 @@ 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -2,7 +2,7 @@ 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 @@ 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 @@ def _create_project_tree():

			




	
	
	
		
 
        username=u'test_u1', password=u'qweqwe',

			




	
	
	
		
 
        email=u'test_u1@rhodecode.org', 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -14,6 +14,9 @@ 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 @@ 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
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -12,7 +12,6 @@ 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 @@ class TestReposGroups(unittest.TestCase)

			




	
	
	
		
 
        pass

			




	
	
	
		
 

			




	
	
	
		
 
    def tearDown(self):

			




	
	
	
		
 
        pass

			




	
	
	
		
 
        Session.remove()

			




	
	
	
		
 

			




	
	
	
		
 
    def test_Message_extractor(self):

			




	
	
	
		
 
        validator = v.ValidUsername()

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.