if c.rhodecode_repo.revisions else 0

            if last_rev == 0 or c.repo_last_rev == 0:

                pass

            else:

                c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                                c.repo_last_rev) * 100)

        else:

            c.commit_data = json.dumps({})

            c.overview_data = json.dumps([[ts_min_y, 0], [ts_max_y, 10]])

            c.trending_languages = json.dumps({})

            c.no_data = True

        c.enable_downloads = dbrepo.enable_downloads

        if c.enable_downloads:

            c.download_options = self._get_download_links(c.rhodecode_repo)

        c.readme_data, c.readme_file = \

            self.__get_readme_data(c.rhodecode_db_repo)

        return render('summary/summary.html')

    @NotAnonymous()

    @jsonify

    def repo_size(self, repo_name):

        if request.is_xhr:

        else:

            raise HTTPBadRequest()

    def __get_readme_data(self, db_repo):

        repo_name = db_repo.repo_name

        @cache_region('long_term')

        def _get_readme_from_cache(key):

            readme_data = None

            readme_file = None

            log.debug('Looking for README file')

            try:

                # get's the landing revision! or tip if fails

                cs = db_repo.get_landing_changeset()

                if isinstance(cs, EmptyChangeset):

                    raise EmptyRepositoryError()

                renderer = MarkupRenderer()

                for f in README_FILES:

                    try:

                        readme = cs.get_node(f)

                        if not isinstance(readme, FileNode):

                            continue

                        readme_file = f

                        log.debug('Found README file `%s` rendering...' %

.file_history {

    padding-top: 10px;

    font-size: 16px;

}

.file_author {

    float: left;

}

.file_author .item {

    float: left;

    padding: 5px;

    color: #888;

}

.tablerow0 {

    background-color: #F8F8F8;

}

.tablerow1 {

    background-color: #FFFFFF;

}

.changeset_id {

    color: #666666;

}

.changeset_hash {

    color: #000000;

}

#changeset_content {

    border-left: 1px solid #CCC;

    border-right: 1px solid #CCC;

    border-bottom: 1px solid #CCC;

    padding: 5px;

}

#changeset_compare_view_content {

    border: 1px solid #CCC;

    padding: 5px;

}

#changeset_content .container {

    min-height: 100px;

    font-size: 1.2em;

    overflow: hidden;

}

    border-collapse: collapse;

    border-left: none;

    border-right: none;

    border-color: #cdcdcd;

}

#graph_content .container {

}

#graph_content #changesets td {

    overflow: hidden;

    text-overflow: ellipsis;

    white-space: nowrap;

    height: 31px;

    border-color: #cdcdcd;

    text-align: left;

}

#graph_content .container .author {

   width: 105px;

}

#graph_content .container .hash {

    font-size: 0.85em;

}

#graph_content #changesets .container .date {

    width: 76px;

    color: #666;

    font-size: 10px;

}

#graph_content #changesets .container .right {

    width: 120px;

    padding-right: 0px;

    overflow: visible;

    position: relative;

}

#graph_content .container .mid {

    padding: 0;

}

#graph_content .log-container {

    position: relative;

}

                        ${h.text('size',size=1,value=c.size)}

                        ${_('revisions')}

                    </div>

                    ${h.end_form()}

                    <div style="float:right">${h.select('branch_filter',c.branch_name,c.branch_filters)}</div>

                </div>

                <div id="graph_nodes">

                    <canvas id="graph_canvas"></canvas>

                </div>

                <div id="graph_content">

                <table id="changesets">

                <tbody>

                %for cnt,cs in enumerate(c.pagination):

                    <tr id="chg_${cnt+1}" class="container ${'tablerow%s' % (cnt%2)}">

                        <td class="checkbox">

                            ${h.checkbox(cs.raw_id,class_="changeset_range")}

                        </td>

                        <td class="author">

                            <img alt="gravatar" src="${h.gravatar_url(h.email_or_none(cs.author),16)}"/>

                            <span title="${cs.author}" class="user">${h.shorter(h.person(cs.author),22)}</span>

                        </td>

                        <td class="hash">

                            <a href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id)}">

                                <span class="changeset_hash">${h.short_id(cs.raw_id)}</span>

                            </a>

                        </td>

                        <td class="date">

                            <div class="date">${h.age(cs.date,True)}</div>

                        </td>

                        <td class="mid">

                            <div class="log-container">

                                <div class="message">${h.urlify_commit(cs.message, c.repo_name,h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}</div>

                                <div class="expand"><span class="expandtext">&darr; ${_('Show more')} &darr;</span></div>

                                <div class="extra-container">

                                    %if c.comments.get(cs.raw_id,[]):

                                        <div class="comments-container">

                                            <div class="comments-cnt" title="${('comments')}">

                                                <a href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id,anchor='comment-%s' % c.comments[cs.raw_id][0].comment_id)}">

                                                    ${len(c.comments[cs.raw_id])}

                                                </a>

                                            </div>

                                        </div>

                                    %endif

                                    %if h.is_hg(c.rhodecode_repo):

                                        %for book in cs.bookmarks:

                                            <div class="bookbook" title="${'%s %s' % (_('bookmark'),book)}">

                                                ${h.link_to(h.shorter(book),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}

"""

import os

import time

import logging

import datetime

import hashlib

import tempfile

from os.path import join as jn

from unittest import TestCase

from tempfile import _RandomNameSequence

from paste.deploy import loadapp

from paste.script.appinstall import SetupCommand

from pylons import config, url

from routes.util import URLGenerator

from webtest import TestApp

from rhodecode import is_windows

from rhodecode.model.meta import Session

from rhodecode.model.db import User

from rhodecode.tests.nose_parametrized import parameterized

import pylons.test

os.environ['TZ'] = 'UTC'

if not is_windows:

    time.tzset()

log = logging.getLogger(__name__)

__all__ = [

    'parameterized', 'environ', 'url', 'get_new_dir', 'TestController',

    'TESTS_TMP_PATH', 'HG_REPO', 'GIT_REPO', 'NEW_HG_REPO', 'NEW_GIT_REPO',

    'HG_FORK', 'GIT_FORK', 'TEST_USER_ADMIN_LOGIN', 'TEST_USER_ADMIN_PASS',

    'TEST_USER_REGULAR_LOGIN', 'TEST_USER_REGULAR_PASS',

    'TEST_USER_REGULAR_EMAIL', 'TEST_USER_REGULAR2_LOGIN',

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

]

# Invoke websetup with the current config file

# SetupCommand('setup-app').run([config_file])

    def log_user(self, username=TEST_USER_ADMIN_LOGIN,

                 password=TEST_USER_ADMIN_PASS):

        self._logged_username = username

        response = self.app.post(url(controller='login', action='index'),

                                 {'username': username,

                                  'password': password})

        if 'invalid user name' in response.body:

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

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

        ses = response.session['rhodecode_user']

        self.assertEqual(ses.get('username'), username)

        response = response.follow()

        self.assertEqual(ses.get('is_authenticated'), True)

        return response.session['rhodecode_user']

    def _get_logged_user(self):

        return User.get_by_username(self._logged_username)

    def checkSessionFlash(self, response, msg):

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

        if not msg in response.session['flash'][0][1]:

## 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,

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

import os

from rhodecode.lib import vcs

from rhodecode.model.db import Repository, RepoGroup

from rhodecode.tests import *

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.model.repo import RepoModel

class TestAdminReposController(TestController):

    def __make_repo(self):

        pass

    def test_index(self):

        self.log_user()

        response = self.app.get(url('repos'))

        # Test response...

    def test_index_as_xml(self):

        response = self.app.get(url('formatted_repos', format='xml'))

    def test_create_hg(self):

        self.log_user()

        repo_name = NEW_HG_REPO

        description = 'description for newly created repo'

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

                        _get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_description=description))

        self.checkSessionFlash(response,

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == repo_name).one()

        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.mustcontain(repo_name)

        #test if repository was created on filesystem

        try:

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

        except:

            self.fail('no repo %s in filesystem' % repo_name)

    def test_create_hg_non_ascii(self):

        self.log_user()

        non_ascii = "ąęł"

        repo_name = "%s%s" % (NEW_HG_REPO, non_ascii)

        repo_name_unicode = repo_name.decode('utf8')

        description = 'description for newly created repo' + non_ascii

        description_unicode = description.decode('utf8')

        private = False

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

                        _get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_description=description))

        self.checkSessionFlash(response,

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == repo_name_unicode).one()

        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()

        response.mustcontain(repo_name)

        #test if repository was created on filesystem

        try:

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

        except:

            self.fail('no repo %s in filesystem' % repo_name)

    def test_create_hg_in_group(self):

        self.log_user()

        ## create GROUP

        group_name = 'sometest'

        gr = ReposGroupModel().create(group_name=group_name,

                                      group_description='test',

                                      owner=TEST_USER_ADMIN_LOGIN)

        self.Session().commit()

        repo_name = 'ingroup'

        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,

                                                repo_name=repo_name,

                                                repo_description=description,

                                                repo_group=gr.group_id,))

        self.checkSessionFlash(response,

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == repo_name_full).one()

        self.assertEqual(new_repo.repo_name, repo_name_full)

        self.assertEqual(new_repo.description, description)

        #test if repository is visible in the list ?

        response = response.follow()

        response.mustcontain(repo_name_full)

        #test if repository was created on filesystem

        try:

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

        except:

            ReposGroupModel().delete(group_name)

            self.Session().commit()

            self.fail('no repo %s in filesystem' % repo_name)

        RepoModel().delete(repo_name_full)

        ReposGroupModel().delete(group_name)

        self.Session().commit()

    def test_create_git(self):

        self.log_user()

        repo_name = NEW_GIT_REPO

        description = 'description for newly created repo'

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

                        _get_repo_create_params(repo_private=False,

                                                repo_type='git',

                                                repo_name=repo_name,

                                                repo_description=description))

        self.checkSessionFlash(response,

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == repo_name).one()

        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.mustcontain(repo_name)

        #test if repository was created on filesystem

        try:

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

        except:

            self.fail('no repo %s in filesystem' % repo_name)

    def test_create_git_non_ascii(self):

        self.log_user()

        non_ascii = "ąęł"

        repo_name = "%s%s" % (NEW_GIT_REPO, non_ascii)

        repo_name_unicode = repo_name.decode('utf8')

        description = 'description for newly created repo' + non_ascii

        description_unicode = description.decode('utf8')

        private = False

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

                        _get_repo_create_params(repo_private=False,

                                                repo_type='git',

                                                repo_name=repo_name,

                                                repo_description=description))

        self.checkSessionFlash(response,

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == repo_name_unicode).one()

        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()

        response.mustcontain(repo_name)

        #test if repository was created on filesystem

        try:

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

        except:

            self.fail('no repo %s in filesystem' % repo_name)

    def test_new(self):

        self.log_user()

        response = self.app.get(url('new_repo'))

    def test_new_as_xml(self):

        response = self.app.get(url('formatted_new_repo', format='xml'))

    def test_update(self):

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

    def test_update_browser_fakeout(self):

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

                                 params=dict(_method='put'))

    def test_delete_hg(self):

        self.log_user()

        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,

                                                repo_type='hg',

                                                repo_name=repo_name,

                                                repo_description=description))

        self.checkSessionFlash(response,

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == repo_name).one()

        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.mustcontain(repo_name)

        #test if repository was created on filesystem

        try:

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

        except:

            self.fail('no repo %s in filesystem' % repo_name)

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

        self.assertTrue('''deleted repository %s''' % (repo_name) in

                        response.session['flash'][0])

        response.follow()

        #check if repo was deleted from db

        deleted_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == repo_name).scalar()

        self.assertEqual(deleted_repo, None)

        self.assertEqual(os.path.isdir(os.path.join(TESTS_TMP_PATH, repo_name)),

                                  False)

    def test_delete_git(self):

        self.log_user()

        repo_name = 'vcs_test_new_to_delete'

        description = 'description for newly created repo'

        private = False

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

                        _get_repo_create_params(repo_private=False,

                                                repo_type='git',

                                                repo_name=repo_name,

                                                repo_description=description))

        self.checkSessionFlash(response,

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

            .filter(Repository.repo_name == repo_name).one()

        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.mustcontain(repo_name)

        #test if repository was created on filesystem

        try:

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

        except:

            self.fail('no repo %s in filesystem' % repo_name)

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

        self.assertTrue('''deleted repository %s''' % (repo_name) in

                        response.session['flash'][0])

        response.follow()

from rhodecode.tests import *

class TestChangelogController(TestController):

    def test_index_hg(self):

        self.log_user()

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

                                    repo_name=HG_REPO))

        response.mustcontain(

            """<input class="changeset_range" """

            """id="5e204e7583b9c8e7b93a020bd036564b1e731dae" """

            """name="5e204e7583b9c8e7b93a020bd036564b1e731dae" """

            """type="checkbox" value="1" />"""

        )

        response.mustcontain(

        )

        response.mustcontain("""Small update at simplevcs app""")

        #pagination

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

                                    repo_name=HG_REPO), {'page': 1})

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

                                    repo_name=HG_REPO), {'page': 2})

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

                                    repo_name=HG_REPO), {'page': 3})

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

                                    repo_name=HG_REPO), {'page': 4})

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

                                    repo_name=HG_REPO), {'page': 5})

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

                                    repo_name=HG_REPO), {'page': 6})

        # Test response after pagination...

        response.mustcontain(

            """<input class="changeset_range" """

            """id="46ad32a4f974e45472a898c6b0acb600320579b1" """

            """name="46ad32a4f974e45472a898c6b0acb600320579b1" """

            """type="checkbox" value="1" />"""

        )

        response.mustcontain(

        )

            """<a href="/%s">%s</a>""" % (fork_name, fork_name)

        )

        #remove this fork

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

    def test_z_fork_create(self):

        self.log_user()

        fork_name = HG_FORK

        description = 'fork of vcs test'

        repo_name = HG_REPO

        org_repo = Repository.get_by_repo_name(repo_name)

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

                                    repo_name=repo_name),

                                    {'repo_name':fork_name,

                                     'repo_group':'',

                                     'fork_parent_id':org_repo.repo_id,

                                     'repo_type':'hg',

                                     'description':description,

                                     'private':'False',

                                     'landing_rev': 'tip'})

        #test if we have a message that fork is ok

        self.checkSessionFlash(response,

        #test if the fork was created in the database

        fork_repo = Session().query(Repository)\

            .filter(Repository.repo_name == fork_name).one()

        self.assertEqual(fork_repo.repo_name, fork_name)

        self.assertEqual(fork_repo.fork.repo_name, repo_name)

        #test if fork is visible in the list ?

        response = response.follow()

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

                                    repo_name=fork_name))

        self.assertTrue('Fork of %s' % repo_name in response.body)

    def test_zz_fork_permission_page(self):

        usr = self.log_user(self.username, self.password)['user_id']

        repo_name = HG_REPO

        forks = Session().query(Repository)\

            .filter(Repository.fork_id != None)\

            .all()

        self.assertEqual(1, len(forks))