'hg': 'Mercurial repository',

    #'git': 'Git repository',

}

from pylons.configuration import PylonsConfig

from pylons.error import handle_mako_error

import rhodecode.lib.app_globals as app_globals

import rhodecode.lib.helpers

from rhodecode.config.routing import make_map

from rhodecode.lib import engine_from_config

from rhodecode.lib.auth import set_available_permissions

from rhodecode.lib.utils import repo2db_mapper, make_ui, set_rhodecode_config

from rhodecode.model import init_model

    # Initialize config with the basic options

    config.init_app(global_conf, app_conf, package='rhodecode', paths=paths)

    config['routes.map'] = make_map(config)

    config['pylons.app_globals'] = app_globals.Globals(config)

    config['pylons.h'] = rhodecode.lib.helpers

        from rhodecode.lib.utils import create_test_env, create_test_index

        from rhodecode.tests import  TESTS_TMP_PATH

        create_test_env(TESTS_TMP_PATH, config)

    #MULTIPLE DB configs

    # Setup the SQLAlchemy database engine

import traceback

from pylons import tmpl_context as c, url

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import Notification

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib import helpers as h

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

from hashlib import md5

from decorator import decorator

from vcs.utils.lazy import LazyProperty

from rhodecode.lib import str2bool, safe_str

from rhodecode.lib.pidlock import DaemonLock, LockHeld

log = logging.getLogger(__name__)

class ResultWrapper(object):

from vcs import get_backend

from rhodecode.lib import LANGUAGES_EXTENSIONS_MAP, safe_str

from rhodecode.lib.celerylib import run_task, locked_task, str2bool, \

    __get_lockkey, LockHeld, DaemonLock

           'reset_user_password', 'send_email']

def get_session():

    if CELERY_ON:

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

                         'group_id': getattr(group, 'group_id', None)

                         }

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

    removed = []

    if remove_obsolete:

        #remove from database those repositories that are not in the filesystem

import logging

import datetime

import traceback

from sqlalchemy import *

from sqlalchemy.ext.hybrid import hybrid_property

from sqlalchemy.orm import relationship, joinedload, class_mapper, validates

from beaker.cache import cache_region, region_invalidate

from vcs.exceptions import VCSError

from vcs.utils.lazy import LazyProperty

from rhodecode.lib.exceptions import UsersGroupsAssignedException

from rhodecode.lib.compat import json

from rhodecode.lib.caching_query import FromCache

    @property

    def action_as_day(self):

    user = relationship('User')

    repository = relationship('Repository')

import traceback

import datetime

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

from rhodecode.model.db import Notification, User, UserNotification

class NotificationModel(BaseModel):

    def __get_user(self, user):

        if isinstance(user, basestring):

            return User.get_by_username(username=user)

                raise Exception('notification must be int or Instance'

                                ' of Notification got %s' % type(notification))

    def create(self, created_by, subject, body, recipients,

               type_=Notification.TYPE_MESSAGE):

        """

                                    body=body, recipients=recipients_objs,

                                    type_=type_)

        # send email with notification

        for rec in recipients_objs:

            email_subject = NotificationModel().make_description(notif, False)

    TYPE_DEFAULT = 'default'

    def __init__(self):

        self.email_types = {

            self.TYPE_CHANGESET_COMMENT:'email_templates/changeset_comment.html',

        :param type_:

        """

        base = self.email_types.get(type_, self.TYPE_DEFAULT)

        # translator inject

        _kwargs = {'_':_}

        _kwargs.update(kwargs)

from os.path import join as jn

from unittest import TestCase

from paste.deploy import loadapp

from paste.script.appinstall import SetupCommand

from routes.util import URLGenerator

from webtest import TestApp

from rhodecode.model.db import User

import pylons.test

environ = {}

#SOME GLOBALS FOR TESTS

TESTS_TMP_PATH = jn('/', 'tmp', 'rc_test_%s' % _RandomNameSequence().next())

TEST_USER_ADMIN_LOGIN = 'test_admin'

TEST_USER_ADMIN_PASS = 'test12'

        self.app = TestApp(wsgiapp)

        url._push_object(URLGenerator(config['routes.map'], environ))

        self.index_location = config['app_conf']['index_dir']

        TestCase.__init__(self, *args, **kwargs)

            self.fail('could not login using %s %s' % (username, password))

        self.assertEqual(response.status, '302 Found')

    def _get_logged_user(self):

        return User.get_by_username(self._logged_username)

    def checkSessionFlash(self, response, msg):

        self.assertTrue('flash' in response.session)

        self.assertTrue(msg in response.session['flash'][0][1])

                                               name='u2', lastname='u2')

        notification = NotificationModel().create(created_by=cur_user,

                                                  body=u'hi there',

                                                  recipients=[cur_user, u1, u2])

    def test_index(self):

        self.log_user()

        users = [x.user.username for x in UserNotification.query().all()]

        # test_regular get's notification by @mention

    def test_delete(self):

        self.log_user()

        self.app.delete(url(controller='changeset',

                                    action='delete_comment',

                                    repo_name=HG_REPO,

        comments = ChangesetComment.query().all()

        self.assertEqual(len(comments), 0)

        fork_name = HG_FORK

        description = 'fork of vcs test'

        repo_name = HG_REPO

                                     action='fork_create',

                                    repo_name=repo_name),

                                     'repo_type':'hg',

                                     'description':description,

                                     'private':'False'})

        #remove this fork

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

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

                                    repo_name=HG_REPO))

        # Test response...