h.flash(_('Successfully committed to %s' % node_path),

                        category='success')

            except NodeAlreadyExistsError, e:

                h.flash(_(e), category='error')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during commit'), category='error')

            return redirect(url('changeset_home',

                                repo_name=c.repo_name, revision='tip'))

        return render('files/files_add.html')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def archivefile(self, repo_name, fname):

        fileformat = None

        revision = None

        ext = None

        subrepos = request.GET.get('subrepos') == 'true'

        for a_type, ext_data in settings.ARCHIVE_SPECS.items():

            archive_spec = fname.split(ext_data[1])

            if len(archive_spec) == 2 and archive_spec[1] == '':

                fileformat = a_type or ext_data[1]

                revision = archive_spec[0]

                ext = ext_data[1]

        try:

            dbrepo = RepoModel().get_by_repo_name(repo_name)

            if dbrepo.enable_downloads is False:

                return _('downloads disabled')

            if c.rhodecode_repo.alias == 'hg':

                # patch and reset hooks section of UI config to not run any

                # hooks on fetching archives with subrepos

                for k, v in c.rhodecode_repo._repo.ui.configitems('hooks'):

                    c.rhodecode_repo._repo.ui.setconfig('hooks', k, None)

            cs = c.rhodecode_repo.get_changeset(revision)

            content_type = settings.ARCHIVE_SPECS[fileformat][0]

        except ChangesetDoesNotExistError:

            return _('Unknown revision %s') % revision

        except EmptyRepositoryError:

            return _('Empty repository')

        except (ImproperArchiveTypeError, KeyError):

            return _('Unknown archive type')

        cs.fill_archive(stream=archive, kind=fileformat, subrepos=subrepos)

        response.content_type = content_type

        response.content_disposition = 'attachment; filename=%s-%s%s' \

            % (repo_name, revision[:12], ext)

        response.content_length = str(os.path.getsize(archive.name))

        def get_chunked_archive(tmpfile):

            while True:

                data = tmpfile.read(16 * 1024)

                if not data:

                    tmpfile.close()

                    break

                yield data

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def diff(self, repo_name, f_path):

        ignore_whitespace = request.GET.get('ignorews') == '1'

        line_context = request.GET.get('context', 3)

        diff1 = request.GET.get('diff1', '')

        diff2 = request.GET.get('diff2', '')

        c.action = request.GET.get('diff')

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        c.big_diff = False

        c.anchor_url = anchor_url

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        c.changes = OrderedDict()

        c.changes[diff2] = []

        try:

            if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_1 = c.rhodecode_repo.get_changeset(diff1)

                node1 = c.changeset_1.get_node(f_path)

            else:

                c.changeset_1 = EmptyChangeset(repo=c.rhodecode_repo)

                node1 = FileNode('.', '', changeset=c.changeset_1)

            if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_2 = c.rhodecode_repo.get_changeset(diff2)

                node2 = c.changeset_2.get_node(f_path)

            else:

                c.changeset_2 = EmptyChangeset(repo=c.rhodecode_repo)

                node2 = FileNode('.', '', changeset=c.changeset_2)

        except RepositoryError:

            return redirect(url('files_home', repo_name=c.repo_name,

                                f_path=f_path))

        if c.action == 'download':

            _diff = diffs.get_gitdiff(node1, node2,

                                      ignore_whitespace=ignore_whitespace,

                                      context=line_context)

            diff = diffs.DiffProcessor(_diff, format='gitdiff')

            diff_name = '%s_vs_%s.diff' % (diff1, diff2)

            response.content_type = 'text/plain'

            response.content_disposition = (

                'attachment; filename=%s' % diff_name

            )

            return diff.raw_diff()

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import random

import logging

import traceback

import hashlib

from tempfile import _RandomNameSequence

from decorator import decorator

from pylons import config, url, request

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode import __platform__, PLATFORM_WIN, PLATFORM_OTHERS

from rhodecode.model.meta import Session

if __platform__ in PLATFORM_WIN:

    from hashlib import sha256

if __platform__ in PLATFORM_OTHERS:

    import bcrypt

from rhodecode.lib.utils2 import str2bool, safe_unicode

from rhodecode.lib.exceptions import LdapPasswordError, LdapUsernameError

from rhodecode.lib.utils import get_repo_slug, get_repos_group_slug

from rhodecode.lib.auth_ldap import AuthLdap

from rhodecode.model import meta

from rhodecode.model.user import UserModel

from rhodecode.model.db import Permission, RhodeCodeSetting, User

log = logging.getLogger(__name__)

class PasswordGenerator(object):

    """

    This is a simple class for generating password from different sets of

    characters

    usage::

        passwd_gen = PasswordGenerator()

        #print 8-letter password containing only big and small letters

            of alphabet

    """

    ALPHABETS_NUM = r'''1234567890'''

    ALPHABETS_SMALL = r'''qwertyuiopasdfghjklzxcvbnm'''

    ALPHABETS_BIG = r'''QWERTYUIOPASDFGHJKLZXCVBNM'''

    ALPHABETS_SPECIAL = r'''`-=[]\;',./~!@#$%^&*()_+{}|:"<>?'''

    ALPHABETS_FULL = ALPHABETS_BIG + ALPHABETS_SMALL \

        + ALPHABETS_NUM + ALPHABETS_SPECIAL

    ALPHABETS_ALPHANUM = ALPHABETS_BIG + ALPHABETS_SMALL + ALPHABETS_NUM

    ALPHABETS_BIG_SMALL = ALPHABETS_BIG + ALPHABETS_SMALL

    ALPHABETS_ALPHANUM_BIG = ALPHABETS_BIG + ALPHABETS_NUM

    ALPHABETS_ALPHANUM_SMALL = ALPHABETS_SMALL + ALPHABETS_NUM

    def __init__(self, passwd=''):

        self.passwd = passwd

    def gen_password(self, length, type_=None):

        if type_ is None:

            type_ = self.ALPHABETS_FULL

        self.passwd = ''.join([random.choice(type_) for _ in xrange(length)])

        return self.passwd

class RhodeCodeCrypto(object):

    @classmethod

    def hash_string(cls, str_):

        """

        Cryptographic function used for password hashing based on pybcrypt

        or pycrypto in windows

        :param password: password to hash

        """

        if __platform__ in PLATFORM_WIN:

            return sha256(str_).hexdigest()

        elif __platform__ in PLATFORM_OTHERS:

            return bcrypt.hashpw(str_, bcrypt.gensalt(10))

        else:

            raise Exception('Unknown or unsupported platform %s' \

                            % __platform__)

    @classmethod

    def hash_check(cls, password, hashed):

        """

        Checks matching password with it's hashed value, runs different

        implementation based on platform it runs on

        :param password: password

        :param hashed: password in hashed form

    try:

        return unicode(str_, from_encoding)

    except UnicodeDecodeError:

        pass

    try:

        import chardet

        encoding = chardet.detect(str_)['encoding']

        if encoding is None:

            raise Exception()

        return str_.decode(encoding)

    except (ImportError, UnicodeDecodeError, Exception):

        return unicode(str_, from_encoding, 'replace')

def safe_str(unicode_, to_encoding=None):

    """

    safe str function. Does few trick to turn unicode_ into string

    In case of UnicodeEncodeError we try to return it with encoding detected

    by chardet library if it fails fallback to string with errors replaced

    :param unicode_: unicode to encode

    :rtype: str

    :returns: str object

    """

    # if it's not basestr cast to str

    if not isinstance(unicode_, basestring):

        return str(unicode_)

    if isinstance(unicode_, str):

        return unicode_

    if not to_encoding:

        import rhodecode

        DEFAULT_ENCODING = rhodecode.CONFIG.get('default_encoding','utf8')

        to_encoding = DEFAULT_ENCODING

    try:

        return unicode_.encode(to_encoding)

    except UnicodeEncodeError:

        pass

    try:

        import chardet

        encoding = chardet.detect(unicode_)['encoding']

        if encoding is None:

            raise UnicodeEncodeError()

        return unicode_.encode(encoding)

    except (ImportError, UnicodeEncodeError):

        return unicode_.encode(to_encoding, 'replace')

    return safe_str

def engine_from_config(configuration, prefix='sqlalchemy.', **kwargs):

    """

    Custom engine_from_config functions that makes sure we use NullPool for

    file based sqlite databases. This prevents errors on sqlite. This only

    applies to sqlalchemy versions < 0.7.0

    """

    import sqlalchemy

    from sqlalchemy import engine_from_config as efc

    import logging

    if int(sqlalchemy.__version__.split('.')[1]) < 7:

        # This solution should work for sqlalchemy < 0.7.0, and should use

        # proxy=TimerProxy() for execution time profiling

        from sqlalchemy.pool import NullPool

        url = configuration[prefix + 'url']

        if url.startswith('sqlite'):

            kwargs.update({'poolclass': NullPool})

        return efc(configuration, prefix, **kwargs)

    else:

        import time

        from sqlalchemy import event

        from sqlalchemy.engine import Engine

        log = logging.getLogger('sqlalchemy.engine')

        BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = xrange(30, 38)

        engine = efc(configuration, prefix, **kwargs)

        def color_sql(sql):

            COLOR_SEQ = "\033[1;%dm"

            COLOR_SQL = YELLOW

            normal = '\x1b[0m'

            return ''.join([COLOR_SEQ % COLOR_SQL, sql, normal])

        if configuration['debug']:

            if branch and branch != cs.branch:

                return _prev(cs, branch)

            return cs

        return _prev(self, branch)

    def get_file_mode(self, path):

        """

        Returns stat mode of the file at the given ``path``.

        """

        # ensure path is traversed

        self._get_id_for_path(path)

        return self._stat_modes[path]

    def get_file_content(self, path):

        """

        Returns content of the file at given ``path``.

        """

        id = self._get_id_for_path(path)

        blob = self.repository._repo[id]

        return blob.as_pretty_string()

    def get_file_size(self, path):

        """

        Returns size of the file at given ``path``.

        """

        id = self._get_id_for_path(path)

        blob = self.repository._repo[id]

        return blob.raw_length()

    def get_file_changeset(self, path):

        """

        Returns last commit of the file at the given ``path``.

        """

        node = self.get_node(path)

        return node.history[0]

    def get_file_history(self, path):

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        TODO: This function now uses os underlying 'git' and 'grep' commands

        which is generally not good. Should be replaced with algorithm

        iterating commits.

        """

                  self.id, path

               )

        so, se = self.repository.run_git_command(cmd)

        return [self.repository.get_changeset(id) for id in ids]

    def get_file_annotate(self, path):

        """

        Returns a list of three element tuples with lineno,changeset and line

        TODO: This function now uses os underlying 'git' command which is

        generally not good. Should be replaced with algorithm iterating

        commits.

        """

        cmd = 'blame -l --root -r %s -- "%s"' % (self.id, path)

        # -l     ==> outputs long shas (and we need all 40 characters)

        # --root ==> doesn't put '^' character for bounderies

        # -r sha ==> blames for the given revision

        so, se = self.repository.run_git_command(cmd)

        annotate = []

        for i, blame_line in enumerate(so.split('\n')[:-1]):

            ln_no = i + 1

            id, line = re.split(r' \(.+?\) ', blame_line, 1)

            annotate.append((ln_no, self.repository.get_changeset(id), line))

        return annotate

    def fill_archive(self, stream=None, kind='tgz', prefix=None,

                     subrepos=False):

        """

        Fills up given stream.

        :param stream: file like object.

        :param kind: one of following: ``zip``, ``tgz`` or ``tbz2``.

            Default: ``tgz``.

        :param prefix: name of root directory in archive.

            Default is repository name and changeset's raw_id joined with dash

            (``repo-tip.<KIND>``).

        :param subrepos: include subrepos in this archive.

        :raise ImproperArchiveTypeError: If given kind is wrong.

        :raise VcsError: If given stream is None

        """

        allowed_kinds = settings.ARCHIVE_SPECS.keys()

        if kind not in allowed_kinds:

            raise ImproperArchiveTypeError('Archive kind not supported use one'

                'of %s', allowed_kinds)

        if prefix is None:

            prefix = '%s-%s' % (self.repository.name, self.short_id)

        elif prefix.startswith('/'):

            raise VCSError("Prefix cannot start with leading slash")

        DEFAULT_ENCODING = rhodecode.CONFIG.get('default_encoding', 'utf8')

        from_encoding = DEFAULT_ENCODING

    try:

        return unicode(str_)

    except UnicodeDecodeError:

        pass

    try:

        return unicode(str_, from_encoding)

    except UnicodeDecodeError:

        pass

    try:

        import chardet

        encoding = chardet.detect(str_)['encoding']

        if encoding is None:

            raise Exception()

        return str_.decode(encoding)

    except (ImportError, UnicodeDecodeError, Exception):

        return unicode(str_, from_encoding, 'replace')

def safe_str(unicode_, to_encoding=None):

    """

    safe str function. Does few trick to turn unicode_ into string

    In case of UnicodeEncodeError we try to return it with encoding detected

    by chardet library if it fails fallback to string with errors replaced

    :param unicode_: unicode to encode

    :rtype: str

    :returns: str object

    """

    if isinstance(unicode_, str):

        return unicode_

    if not to_encoding:

        import rhodecode

        DEFAULT_ENCODING = rhodecode.CONFIG.get('default_encoding', 'utf8')

        to_encoding = DEFAULT_ENCODING

    try:

        return unicode_.encode(to_encoding)

    except UnicodeEncodeError:

        pass

    try:

        import chardet

        encoding = chardet.detect(unicode_)['encoding']

        if encoding is None:

            raise UnicodeEncodeError()

        return unicode_.encode(encoding)

    except (ImportError, UnicodeEncodeError):

        return unicode_.encode(to_encoding, 'replace')

    return safe_str

def author_email(author):

    """

    returns email address of given author.

    If any of <,> sign are found, it fallbacks to regex findall()

    and returns first found result or empty string

    Regex taken from http://www.regular-expressions.info/email.html

    """

    import re

    r = author.find('>')

    l = author.find('<')

    if l == -1 or r == -1:

        # fallback to regex match of email out of a string

        email_re = re.compile(r"""[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!"""

                              r"""#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z"""

                              r"""0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]"""

                              r"""*[a-z0-9])?""", re.IGNORECASE)

        m = re.findall(email_re, author)

        return m[0] if m else ''

    return author[l + 1:r].strip()

def author_name(author):

    """

    get name of author, or else username.

    It'll try to find an email in the author string and just cut it off

    to get the username

    """

    if not '@' in author:

        return author

    else:

        return author.replace(author_email(author), '').replace('<', '')\

            .replace('>', '').strip()

         .all()

        for perm in user_repo_perms_from_users_groups:

            r_k = perm.UsersGroupRepoToPerm.repository.repo_name

            p = perm.Permission.permission_name

            cur_perm = user.permissions[RK][r_k]

            # overwrite permission only if it's greater than permission

            # given from other sources

            if PERM_WEIGHTS[p] > PERM_WEIGHTS[cur_perm]:

                user.permissions[RK][r_k] = p

        # REPO GROUP

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

        # get access for this user for repos group and override defaults

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

        # user explicit permissions for repository

        user_repo_groups_perms = \

         self.sa.query(UserRepoGroupToPerm, Permission, RepoGroup)\

         .join((RepoGroup, UserRepoGroupToPerm.group_id == RepoGroup.group_id))\

         .join((Permission, UserRepoGroupToPerm.permission_id == Permission.permission_id))\

         .filter(UserRepoGroupToPerm.user_id == uid)\

         .all()

        for perm in user_repo_groups_perms:

            rg_k = perm.UserRepoGroupToPerm.group.group_name

            p = perm.Permission.permission_name

            cur_perm = user.permissions[GK][rg_k]

            if PERM_WEIGHTS[p] > PERM_WEIGHTS[cur_perm]:

                user.permissions[GK][rg_k] = p

        # REPO GROUP + USER GROUP

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

        # check if user is part of user groups for this repo group and

        # fill in (or replace with higher) permissions

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

        # users group for repositories permissions

        user_repo_group_perms_from_users_groups = \

         self.sa.query(UsersGroupRepoGroupToPerm, Permission, RepoGroup)\

         .join((RepoGroup, UsersGroupRepoGroupToPerm.group_id == RepoGroup.group_id))\

         .join((Permission, UsersGroupRepoGroupToPerm.permission_id == Permission.permission_id))\

         .join((UsersGroupMember, UsersGroupRepoGroupToPerm.users_group_id == UsersGroupMember.users_group_id))\

         .filter(UsersGroupMember.user_id == uid)\

         .all()

        for perm in user_repo_group_perms_from_users_groups:

            g_k = perm.UsersGroupRepoGroupToPerm.group.group_name

            p = perm.Permission.permission_name

            cur_perm = user.permissions[GK][g_k]

            # overwrite permission only if it's greater than permission

            # given from other sources

            if PERM_WEIGHTS[p] > PERM_WEIGHTS[cur_perm]:

                user.permissions[GK][g_k] = p

        return user

    def has_perm(self, user, perm):

        if not isinstance(perm, Permission):

            raise Exception('perm needs to be an instance of Permission class '

                            'got %s instead' % type(perm))

        user = self.__get_user(user)

        return UserToPerm.query().filter(UserToPerm.user == user)\

            .filter(UserToPerm.permission == perm).scalar() is not None

    def grant_perm(self, user, perm):

        """

        Grant user global permissions

        :param user:

        :param perm:

        """

        user = self.__get_user(user)

        perm = self.__get_perm(perm)

        # if this permission is already granted skip it

        _perm = UserToPerm.query()\

            .filter(UserToPerm.user == user)\

            .filter(UserToPerm.permission == perm)\

            .scalar()

        if _perm:

            return

        new = UserToPerm()

        new.user = user

        new.permission = perm

        self.sa.add(new)

    def revoke_perm(self, user, perm):

        """

        Revoke users global permissions

        :param user:

        :param perm:

        """

        user = self.__get_user(user)

<option value="75feb4c33e81186c87eac740cee2447330288412">r109:75feb4c33e81 (default)</option>

<option value="9a4dc232ecdc763ef2e98ae2238cfcbba4f6ad8d">r108:9a4dc232ecdc (default)</option>

<option value="595cce4efa21fda2f2e4eeb4fe5f2a6befe6fa2d">r107:595cce4efa21 (default)</option>

<option value="4a8bd421fbc2dfbfb70d85a3fe064075ab2c49da">r104:4a8bd421fbc2 (default)</option>

<option value="57be63fc8f85e65a0106a53187f7316f8c487ffa">r102:57be63fc8f85 (default)</option>

<option value="5530bd87f7e2e124a64d07cb2654c997682128be">r101:5530bd87f7e2 (git)</option>

<option value="e516008b1c93f142263dc4b7961787cbad654ce1">r99:e516008b1c93 (default)</option>

<option value="41f43fc74b8b285984554532eb105ac3be5c434f">r93:41f43fc74b8b (default)</option>

<option value="cc66b61b8455b264a7a8a2d8ddc80fcfc58c221e">r92:cc66b61b8455 (default)</option>

<option value="73ab5b616b3271b0518682fb4988ce421de8099f">r91:73ab5b616b32 (default)</option>

<option value="e0da75f308c0f18f98e9ce6257626009fdda2b39">r82:e0da75f308c0 (default)</option>

<option value="fb2e41e0f0810be4d7103bc2a4c7be16ee3ec611">r81:fb2e41e0f081 (default)</option>

<option value="602ae2f5e7ade70b3b66a58cdd9e3e613dc8a028">r76:602ae2f5e7ad (default)</option>

<option value="a066b25d5df7016b45a41b7e2a78c33b57adc235">r73:a066b25d5df7 (default)</option>

<option value="637a933c905958ce5151f154147c25c1c7b68832">r61:637a933c9059 (web)</option>

<option value="0c21004effeb8ce2d2d5b4a8baf6afa8394b6fbc">r60:0c21004effeb (web)</option>

<option value="a1f39c56d3f1d52d5fb5920370a2a2716cd9a444">r59:a1f39c56d3f1 (web)</option>

<option value="97d32df05c715a3bbf936bf3cc4e32fb77fe1a7f">r58:97d32df05c71 (web)</option>

<option value="08eaf14517718dccea4b67755a93368341aca919">r57:08eaf1451771 (web)</option>

<option value="22f71ad265265a53238359c883aa976e725aa07d">r56:22f71ad26526 (web)</option>

<option value="97501f02b7b4330924b647755663a2d90a5e638d">r49:97501f02b7b4 (web)</option>

<option value="86ede6754f2b27309452bb11f997386ae01d0e5a">r47:86ede6754f2b (web)</option>

<option value="014c40c0203c423dc19ecf94644f7cac9d4cdce0">r45:014c40c0203c (web)</option>

<option value="ee87846a61c12153b51543bf860e1026c6d3dcba">r30:ee87846a61c1 (default)</option>

<option value="9bb326a04ae5d98d437dece54be04f830cf1edd9">r26:9bb326a04ae5 (default)</option>

<option value="536c1a19428381cfea92ac44985304f6a8049569">r24:536c1a194283 (default)</option>

<option value="dc5d2c0661b61928834a785d3e64a3f80d3aad9c">r8:dc5d2c0661b6 (default)</option>

<option value="3803844fdbd3b711175fc3da9bdacfcd6d29a6fb">r7:3803844fdbd3 (default)</option>

</optgroup>

<optgroup label="Branches">

<option selected="selected" value="27cd5cce30c96924232dffcd24178a07ffeb5dfc">default</option>

<option value="97e8b885c04894463c51898e14387d80c30ed1ee">git</option>

<option value="2e6a2bf9356ca56df08807f4ad86d480da72a8f4">web</option>

</optgroup>

<optgroup label="Tags">

<option selected="selected" value="27cd5cce30c96924232dffcd24178a07ffeb5dfc">tip</option>

<option value="fd4bdb5e9b2a29b4393a4ac6caef48c17ee1a200">0.1.4</option>

<option value="17544fbfcd33ffb439e2b728b5d526b1ef30bfcf">0.1.3</option>

<option value="a7e60bff65d57ac3a1a1ce3b12a70f8a9e8a7720">0.1.2</option>

<option value="eb3a60fc964309c1a318b8dfe26aa2d1586c85ae">0.1.1</option>

</optgroup>""")

        response.mustcontain("""<span style="text-transform: uppercase;"><a href="#">branch: default</a></span>""")

    def test_archival(self):

        self.log_user()

        for arch_ext, info in ARCHIVE_SPECS.items():

            fname = '27cd5cce30c96924232dffcd24178a07ffeb5dfc%s' % arch_ext

                                        repo_name=HG_REPO,

                                        fname=fname))

            self.assertEqual(response.status, '200 OK')

            self.assertEqual(response.response._headers.items(),

             [('Pragma', 'no-cache'),

              ('Cache-Control', 'no-cache'),

              ('Content-Type', '%s; charset=utf-8' % info[0]),

            )

    def test_archival_wrong_ext(self):

        self.log_user()

        for arch_ext in ['tar', 'rar', 'x', '..ax', '.zipz']:

            fname = '27cd5cce30c96924232dffcd24178a07ffeb5dfc%s' % arch_ext

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

                                        repo_name=HG_REPO,

                                        fname=fname))

            response.mustcontain('Unknown archive type')

    def test_archival_wrong_revision(self):

        self.log_user()

        for rev in ['00x000000', 'tar', 'wrong', '@##$@$424213232', '232dffcd']:

            fname = '%s.zip' % rev

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

                                        repo_name=HG_REPO,

                                        fname=fname))

            response.mustcontain('Unknown revision')

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

    # RAW FILE

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

    def test_raw_file_ok(self):

        self.log_user()

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

                                    repo_name=HG_REPO,

                                    revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',

                                    f_path='vcs/nodes.py'))

        self.assertEqual(response.content_disposition, "attachment; filename=nodes.py")

        self.assertEqual(response.content_type, "text/x-python")

    def test_raw_file_wrong_cs(self):

        self.log_user()

        rev = u'ERRORce30c96924232dffcd24178a07ffeb5dfc'

        f_path = 'vcs/nodes.py'

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

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path))

        msg = """Revision %r does not exist for this repository""" % (rev)