repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    def __load_data(self, repo_name=None):

        """

            return redirect(url('repos'))

        c.default_user_id = User.get_by_username('default').user_id

        c.in_public_journal = UserFollowing.query()\

            .filter(UserFollowing.user_id == c.default_user_id)\

        c.repos_list = [('', _('--REMOVE FORK--'))]

        c.repos_list += [(x.repo_id, x.repo_name) for x in

                   Repository.query().order_by(Repository.repo_name).all()]

        return defaults

    @HasPermissionAllDecorator('hg.admin')

        c.repo_groups = RepoGroup.groups_choices()

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        new_repo = request.GET.get('repo', '')

        c.new_repo = repo_name_slug(new_repo)

             'description': repo.description \

                if repo.description != 'unknown' else '%s repository' % name,

             'private': False,

            }

            rm.create(form_data, user, just_db=True)

    sa.commit()

    install test repository into tmp dir

    """

    from rhodecode.lib.db_manage import DbManage

    # PART ONE create db

    dbconf = config['sqlalchemy.db1.url']

        log.debug('remove %s' % data_path)

        shutil.rmtree(data_path)

    cur_dir = dn(dn(abspath(__file__)))

    tar = tarfile.open(jn(cur_dir, 'tests', "vcs_test_hg.tar.gz"))

    tar.extractall(jn(TESTS_TMP_PATH, HG_REPO))

    tar.close()

    #LOAD VCS test stuff

    from rhodecode.tests.vcs import setup_package

    setup_package()

    password = Column("password", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    active = Column("active", Boolean(), nullable=True, unique=None, default=None)

    admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)

    lastname = Column("lastname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    _email = Column("email", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)

    repo_id = Column("repo_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    repo_name = Column("repo_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)

    clone_uri = Column("clone_uri", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=False, default=None)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)

    private = Column("private", Boolean(), nullable=True, unique=None, default=None)

    enable_statistics = Column("statistics", Boolean(), nullable=True, unique=None, default=True)

    enable_downloads = Column("downloads", Boolean(), nullable=True, unique=None, default=True)

    description = Column("description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    created_on = Column('created_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

    fork_id = Column("fork_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=False, default=None)

    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=False, default=None)

        clone_uri = All(UnicodeString(strip=True, min=1, not_empty=False))

        repo_group = OneOf(repo_groups, hideList=True)

        repo_type = OneOf(supported_backends)

        private = StringBoolean(if_missing=False)

        enable_statistics = StringBoolean(if_missing=False)

        enable_downloads = StringBoolean(if_missing=False)

        if edit:

            #this is repo owner

    return _RepoForm

    class _RepoForkForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

    return _RepoForkForm

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        description = UnicodeString(strip=True, min=1, not_empty=True)

        repo_group = OneOf(repo_groups, hideList=True)

        private = StringBoolean(if_missing=False)

        chained_validators = [ValidRepoName(edit, old_data), ValidPerms(),

                              ValidSettings]

    return _RepoForm

import cStringIO

from sqlalchemy import func

from rhodecode.lib.vcs import get_backend

from rhodecode.lib.vcs.exceptions import RepositoryError

    def get_unread_journal(self):

        return self.sa.query(UserLog).count()

            </div>

         </div>

        <div class="field">

            <div class="label label-textarea">

                <label for="description">${_('Description')}:</label>

            </div>

                </div>

            </div>

            <div class="field">

                <div class="label label-textarea">

                    <label for="description">${_('Description')}:</label>

                </div>

        </div>

        ${h.end_form()}

        ${h.form(url('repo_as_fork', repo_name=c.repo_info.repo_name),method='put')}

        <div class="form">

           <div class="fields">

           </div>

               <div class="field" style="border:none;color:#888">

               <ul>

               </ul>

               </div>

        </div>

log = logging.getLogger(__name__)

__all__ = [

    'TEST_USER_REGULAR_PASS', 'TEST_USER_REGULAR_EMAIL',

    'TEST_USER_REGULAR2_LOGIN', 'TEST_USER_REGULAR2_PASS',

]

# Invoke websetup with the current config file

SCM_TESTS = ['hg', 'git']

uniq_suffix = str(int(time.mktime(datetime.datetime.now().timetuple())))

TEST_GIT_REPO = jn(TESTS_TMP_PATH, GIT_REPO)

TEST_GIT_REPO_CLONE = jn(TESTS_TMP_PATH, 'vcsgitclone%s' % uniq_suffix)

TEST_GIT_REPO_PULL = jn(TESTS_TMP_PATH, 'vcsgitpull%s' % uniq_suffix)

HG_REMOTE_REPO = 'http://bitbucket.org/marcinkuzminski/vcs'

TEST_HG_REPO_CLONE = jn(TESTS_TMP_PATH, 'vcshgclone%s' % uniq_suffix)

TEST_HG_REPO_PULL = jn(TESTS_TMP_PATH, 'vcshgpull%s' % uniq_suffix)

TEST_DIR = tempfile.gettempdir()

TEST_REPO_PREFIX = 'vcs-test'

def get_new_dir(title):

    """

    return get_normalized_path(path)

class TestController(TestCase):

    def __init__(self, *args, **kwargs):

from rhodecode.model.db import Repository

from rhodecode.tests import *

class TestAdminReposController(TestController):

    def __make_repo(self):

                                                'clone_uri':'',

                                                'repo_group':'',

                                                'description':description,

        #test if the repo was created in the database

        self.assertEqual(new_repo.repo_name, repo_name)

        self.assertEqual(new_repo.description, description)

        #test if repository is visible in the list ?

        response = response.follow()

        #test if repository was created on filesystem

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name))

        except:

    def test_create_hg_non_ascii(self):

        self.log_user()

                                                'clone_uri':'',

                                                'repo_group':'',

                                                'description':description,

        self.checkSessionFlash(response,

                               'created repository %s' % (repo_name_unicode))

        #test if the repo was created in the database

        self.assertEqual(new_repo.repo_name, repo_name_unicode)

        self.assertEqual(new_repo.description, description_unicode)

        #test if repository is visible in the list ?

        response = response.follow()

        #test if repository was created on filesystem

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name))

        except:

    def test_create_hg_in_group(self):

        #TODO: write test !

        pass

    def test_create_git(self):

        self.log_user()

        repo_name = NEW_GIT_REPO

        description = 'description for newly created repo'

                                                'clone_uri':'',

                                                'repo_group':'',

                                                'description':description,

        #test if repository is visible in the list ?

        response = response.follow()

        #test if repository was created on filesystem

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name))

        except:

    def test_new(self):

        self.log_user()

        response = self.app.post(url('repo', repo_name=HG_REPO),

                                 params=dict(_method='put'))

        self.log_user()

        repo_name = 'vcs_test_new_to_delete'

        description = 'description for newly created repo'

        private = False

        response = self.app.post(url('repos'), {'repo_name':repo_name,

                                                'repo_type':'hg',

                                                'clone_uri':'',

                                                'repo_group':'',

                                                'description':description,

        #test if the repo was created in the database

        self.assertEqual(new_repo.repo_name, repo_name)

        self.assertEqual(new_repo.description, description)

        #test if repository is visible in the list ?

        response = response.follow()

        response = self.app.delete(url('repo', repo_name=repo_name))

        response.follow()

        #check if repo was deleted from db

        self.assertEqual(deleted_repo, None)

    def test_delete_repo_with_group(self):

        #TODO:

        pass

    def test_delete_browser_fakeout(self):

        response = self.app.post(url('repo', repo_name=HG_REPO),

                                 params=dict(_method='delete'))

        self.log_user()

        response = self.app.get(url('repo', repo_name=HG_REPO))

    def test_edit(self):

        response = self.app.get(url('edit_repo', repo_name=HG_REPO))

        self.assertTrue("""There are no forks yet""" in response.body)

        self.log_user()

        # create a fork

                                     'fork_parent_id':org_repo.repo_id,

                                     'repo_type':'hg',

                                     'description':description,

        response = self.app.get(url(controller='forks', action='forks',

                                    repo_name=repo_name))

        #remove this fork

        response = self.app.delete(url('repo', repo_name=fork_name))

                                     'fork_parent_id':org_repo.repo_id,

                                     'repo_type':'hg',

                                     'description':description,

        #test if we have a message that fork is ok

        #test if the fork was created in the database

        fork_repo = self.Session.query(Repository)\

        #test if fork is visible in the list ?

        response = response.follow()

        response = self.app.get(url(controller='summary', action='index',

                                    repo_name=fork_name))

from rhodecode.tests import *

from nose.plugins.skip import SkipTest

        self.log_user()

        response = self.app.get(url(controller='search', action='index'),

                                {'q': 'def repo'})

    def test_repo_search(self):

        self.log_user()

                                {'q': 'repository:%s def test' % HG_REPO})

        response.mustcontain('4 results')

        #repo type

        response.mustcontain("""<img style="margin-bottom:2px" class="icon" """

                        """title="Git repository" alt="Git """

        response.mustcontain("""<img style="margin-bottom:2px" class="icon" """

                        """title="public repository" alt="public """

                        """repository" src="/images/icons/lock_open.png"/>""")

                         repo_group=None,

                         private=False,

                         repo_type='hg',

        cur_user = User.get_by_username(TEST_USER_ADMIN_LOGIN)

        r = RepoModel().create(form_data, cur_user)

                                                user=self.anon,

                                                perm='group.none')

        u1_auth = AuthUser(user_id=self.u1.user_id)

        self.assertEqual(u1_auth.permissions['repositories_groups'],

                 {u'group1': u'group.none', u'group2': u'group.none'})

            'clone_uri':'',

            'repo_group':self.g1.group_id,

            'description':'desc',

        }

        self.test_repo = RepoModel().create(form_data, cur_user=self.u1)

        Session.commit()

    except VCSTestError, err:

        raise RuntimeError(str(err))

"""

Unit tests configuration module for vcs.

"""

import os

import time

import hashlib

import tempfile

import datetime

from utils import get_normalized_path

from os.path import join as jn

THIS = os.path.abspath(os.path.dirname(__file__))