conf.INDEX_EXTENSIONS.extend(getattr(EXT, 'EXTRA_INDEX_EXTENSIONS', []))

        # auto check if the module is not missing any data, set to default if is

        # this will help autoupdate new feature of rcext module

        from rhodecode.config import rcextensions

        for k in dir(rcextensions):

            if not k.startswith('_') and not hasattr(EXT, k):

                setattr(EXT, k, getattr(rcextensions, k))

def get_custom_lexer(extension):

    """

    returns a custom lexer if it's defined in rcextensions module, or None

    if there's no custom lexer defined

    """

    import rhodecode

    from pygments import lexers

    #check if we didn't define this extension as other lexer

    if rhodecode.EXTENSIONS and extension in rhodecode.EXTENSIONS.EXTRA_LEXERS:

        _lexer_name = rhodecode.EXTENSIONS.EXTRA_LEXERS[extension]

        return lexers.get_lexer_by_name(_lexer_name)

#==============================================================================

# TEST FUNCTIONS AND CREATORS

#==============================================================================

def create_test_index(repo_location, config, full_index):

    """

    Makes default test index

    :param config: test config

    :param full_index:

    """

    from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

    from rhodecode.lib.pidlock import DaemonLock, LockHeld

    repo_location = repo_location

    index_location = os.path.join(config['app_conf']['index_dir'])

    if not os.path.exists(index_location):

        os.makedirs(index_location)

    try:

        l = DaemonLock(file_=jn(dn(index_location), 'make_index.lock'))

        WhooshIndexingDaemon(index_location=index_location,

                             repo_location=repo_location)\

            .run(full_index=full_index)

        l.release()

    except LockHeld:

        pass

def create_test_env(repos_test_path, config):

    """

    Makes a fresh database and

    install test repository into tmp dir

    """

    from rhodecode.lib.db_manage import DbManage

    from rhodecode.tests import HG_REPO, GIT_REPO, TESTS_TMP_PATH

    # PART ONE create db

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

    log.debug('making test db %s' % dbconf)

    # create test dir if it doesn't exist

    if not os.path.isdir(repos_test_path):

        log.debug('Creating testdir %s' % repos_test_path)

        os.makedirs(repos_test_path)

    dbmanage = DbManage(log_sql=True, dbconf=dbconf, root=config['here'],

                        tests=True)

    dbmanage.create_tables(override=True)

    dbmanage.create_settings(dbmanage.config_prompt(repos_test_path))

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    Session().commit()

    # PART TWO make test repo

    log.debug('making test vcs repositories')

    idx_path = config['app_conf']['index_dir']

    data_path = config['app_conf']['cache_dir']

    #clean index and data

    if idx_path and os.path.exists(idx_path):

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

        shutil.rmtree(idx_path)

    if data_path and os.path.exists(data_path):

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

        shutil.rmtree(data_path)

    #CREATE DEFAULT TEST REPOS

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

    tar.extractall(jn(TESTS_TMP_PATH, HG_REPO))

    tar.close()

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

    tar.extractall(jn(TESTS_TMP_PATH, GIT_REPO))

    tar.close()

    #LOAD VCS test stuff

    from rhodecode.tests.vcs import setup_package

    setup_package()

#==============================================================================

# PASTER COMMANDS

#==============================================================================

class BasePasterCommand(Command):

    """

    Abstract Base Class for paster commands.

    The celery commands are somewhat aggressive about loading

    celery.conf, and since our module sets the `CELERY_LOADER`

    environment variable to our loader, we have to bootstrap a bit and

    make sure we've had a chance to load the pylons config off of the

    command line, otherwise everything fails.

    """

    min_args = 1

    min_args_error = "Please provide a paster config file as an argument."

    takes_config_file = 1

    requires_config_file = True

    def notify_msg(self, msg, log=False):

        """Make a notification to user, additionally if logger is passed

        it logs this action using given logger

        :param msg: message that will be printed to user

        :param log: logging instance, to use to additionally log this message

        """

        if log and isinstance(log, logging):

            log(msg)

    def run(self, args):

        """

        Overrides Command.run

        Checks for a config file argument and loads it.

        """

        if len(args) < self.min_args:

            raise BadCommand(

                self.min_args_error % {'min_args': self.min_args,

                                       'actual_args': len(args)})

        # Decrement because we're going to lob off the first argument.

        # @@ This is hacky

        self.min_args -= 1

        self.bootstrap_config(args[0])

        self.update_parser()

        return super(BasePasterCommand, self).run(args[1:])

    def update_parser(self):

        """

        Abstract method.  Allows for the class's parser to be updated

        before the superclass's `run` method is called.  Necessary to

        allow options/arguments to be passed through to the underlying

        celery command.

        """

        raise NotImplementedError("Abstract Method.")

    def bootstrap_config(self, conf):

        """

        Loads the pylons configuration.

        """

        from pylons import config as pylonsconfig

        self.path_to_ini_file = os.path.realpath(conf)

        conf = paste.deploy.appconfig('config:' + self.path_to_ini_file)

        pylonsconfig.init_app(conf.global_conf, conf.local_conf)

    def _init_session(self):

        """

        Inits SqlAlchemy Session

        """

        logging.config.fileConfig(self.path_to_ini_file)

        from pylons import config

        from rhodecode.model import init_model

        from rhodecode.lib.utils2 import engine_from_config

        #get to remove repos !!

        add_cache(config)

        engine = engine_from_config(config, 'sqlalchemy.db1.')

        init_model(engine)

def check_git_version():

    """

    Checks what version of git is installed in system, and issues a warning

    if it's too old for RhodeCode to properly work.

    """

    from rhodecode import BACKENDS

    from rhodecode.lib.vcs.backends.git.repository import GitRepository

# -*- coding: utf-8 -*-

import unittest

import formencode

from rhodecode.tests import *

from rhodecode.model import validators as v

from rhodecode.model.users_group import UserGroupModel

from rhodecode.model.meta import Session

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.model.db import ChangesetStatus, Repository

from rhodecode.model.changeset_status import ChangesetStatusModel

from rhodecode.tests.fixture import Fixture

fixture = Fixture()

class TestReposGroups(unittest.TestCase):

    def setUp(self):

        pass

    def tearDown(self):

        Session.remove()

    def test_Message_extractor(self):

        validator = v.ValidUsername()

        self.assertRaises(formencode.Invalid, validator.to_python, 'default')

        class StateObj(object):

            pass

        self.assertRaises(formencode.Invalid,

                          validator.to_python, 'default', StateObj)

    def test_ValidUsername(self):

        validator = v.ValidUsername()

        self.assertRaises(formencode.Invalid, validator.to_python, 'default')

        self.assertRaises(formencode.Invalid, validator.to_python, 'new_user')

        self.assertRaises(formencode.Invalid, validator.to_python, '.,')

        self.assertRaises(formencode.Invalid, validator.to_python,

                          TEST_USER_ADMIN_LOGIN)

        self.assertEqual('test', validator.to_python('test'))

        validator = v.ValidUsername(edit=True, old_data={'user_id': 1})

    def test_ValidRepoUser(self):

        validator = v.ValidRepoUser()

        self.assertRaises(formencode.Invalid, validator.to_python, 'nouser')

        self.assertEqual(TEST_USER_ADMIN_LOGIN,

                         validator.to_python(TEST_USER_ADMIN_LOGIN))

    def test_ValidUserGroup(self):

        validator = v.ValidUserGroup()

        self.assertRaises(formencode.Invalid, validator.to_python, 'default')

        self.assertRaises(formencode.Invalid, validator.to_python, '.,')

        gr = fixture.create_user_group('test')

        gr2 = fixture.create_user_group('tes2')

        Session().commit()

        self.assertRaises(formencode.Invalid, validator.to_python, 'test')

        assert gr.users_group_id != None

        validator = v.ValidUserGroup(edit=True,

                                    old_data={'users_group_id':

                                              gr2.users_group_id})

        self.assertRaises(formencode.Invalid, validator.to_python, 'test')

        self.assertRaises(formencode.Invalid, validator.to_python, 'TesT')

        self.assertRaises(formencode.Invalid, validator.to_python, 'TEST')

        UserGroupModel().delete(gr)

        UserGroupModel().delete(gr2)

        Session().commit()

    def test_ValidReposGroup(self):

        validator = v.ValidReposGroup()

        model = ReposGroupModel()

        self.assertRaises(formencode.Invalid, validator.to_python,

                          {'group_name': HG_REPO, })

        gr = model.create(group_name='test_gr', group_description='desc',

                          parent=None,

                          just_db=True,

                          owner=TEST_USER_ADMIN_LOGIN)

        self.assertRaises(formencode.Invalid,

                          validator.to_python, {'group_name': gr.group_name, })

        validator = v.ValidReposGroup(edit=True,

                                      old_data={'group_id':  gr.group_id})

        self.assertRaises(formencode.Invalid,

                          validator.to_python, {

                                        'group_name': gr.group_name + 'n',

                                        'group_parent_id': gr.group_id

                                        })

        model.delete(gr)

    def test_ValidPassword(self):

        validator = v.ValidPassword()

        self.assertEqual('lol', validator.to_python('lol'))

        self.assertEqual(None, validator.to_python(None))

        self.assertRaises(formencode.Invalid, validator.to_python, 'ąćżź')

    def test_ValidPasswordsMatch(self):

        validator = v.ValidPasswordsMatch()

        self.assertRaises(formencode.Invalid,

                    validator.to_python, {'password': 'pass',

                                          'password_confirmation': 'pass2'})