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

"""

    rhodecode.controllers.settings

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Settings controller for rhodecode

    :created_on: Jun 30, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

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

import traceback

import formencode

from formencode import htmlfill

from pylons import tmpl_context as c, request, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAllDecorator,\

    HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import invalidate_cache, action_logger

from rhodecode.model.forms import RepoSettingsForm

from rhodecode.model.repo import RepoModel

from rhodecode.model.db import RepoGroup, Repository

from rhodecode.model.meta import Session

from rhodecode.model.scm import ScmModel

log = logging.getLogger(__name__)

class SettingsController(BaseRepoController):

    @LoginRequired()

    def __before__(self):

        super(SettingsController, self).__before__()

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices(check_perms=True)

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

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

        choices, c.landing_revs = ScmModel().get_repo_landing_revs()

        c.landing_revs_choices = choices

    @HasRepoPermissionAllDecorator('repository.admin')

    def index(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was created or renamed from the file system'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('home'))

        self.__load_defaults()

        defaults = RepoModel()._get_defaults(repo_name)

        return htmlfill.render(

            render('settings/repo_settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    @HasRepoPermissionAllDecorator('repository.admin')

    def update(self, repo_name):

        repo_model = RepoModel()

        changed_name = repo_name

        self.__load_defaults()

        _form = RepoSettingsForm(edit=True,

                                 old_data={'repo_name': repo_name},

                                 repo_groups=c.repo_groups_choices,

                                 landing_revs=c.landing_revs_choices)()

        try:

            form_result = _form.to_python(dict(request.POST))

            repo_model.update(repo_name, form_result)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('Repository %s updated successfully') % repo_name,

                    category='success')

            changed_name = form_result['repo_name_full']

            action_logger(self.rhodecode_user, 'user_updated_repo',

                          changed_name, self.ip_addr, self.sa)

            Session().commit()

        except formencode.Invalid, errors:

            c.repo_info = repo_model.get_by_repo_name(repo_name)

            c.users_array = repo_model.get_users_js()

            errors.value.update({'user': c.repo_info.user.username})

            return htmlfill.render(

                render('settings/repo_settings.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of repository %s') \

                    % repo_name, category='error')

        return redirect(url('repo_settings_home', repo_name=changed_name))

    @HasRepoPermissionAllDecorator('repository.admin')

    def delete(self, repo_name):

        """DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo_settings_delete', repo_name=ID),

        #           method='delete')

        # url('repo_settings_delete', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was moved or renamed  from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('home'))

        try:

            action_logger(self.rhodecode_user, 'user_deleted_repo',

                              repo_name, self.ip_addr, self.sa)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('deleted repository %s') % repo_name, category='success')

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        return redirect(url('home'))

    @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')

    def toggle_locking(self, repo_name):

        """

        Toggle locking of repository by simple GET call to url

        :param repo_name:

        """

        try:

            repo = Repository.get_by_repo_name(repo_name)

            if repo.enable_locking:

                if repo.locked[0]:

                    Repository.unlock(repo)

                    action = _('unlocked')

                else:

                    Repository.lock(repo, c.rhodecode_user.user_id)

                    action = _('locked')

                h.flash(_('Repository has been %s') % action,

                        category='success')

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during unlocking'),

                    category='error')

        return redirect(url('summary_home', repo_name=repo_name))

                .scalar()

        paths.ui_value = paths.ui_value.replace('*', '')

        try:

            self.sa.add(paths)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def fix_default_user(self):

        """

        Fixes a old default user with some 'nicer' default values,

        used mostly for anonymous access

        """

        def_user = self.sa.query(User)\

                .filter(User.username == 'default')\

                .one()

        def_user.name = 'Anonymous'

        def_user.lastname = 'User'

        def_user.email = 'anonymous@rhodecode.org'

        try:

            self.sa.add(def_user)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def fix_settings(self):

        """

        Fixes rhodecode settings adds ga_code key for google analytics

        """

        hgsettings3 = RhodeCodeSetting('ga_code', '')

        try:

            self.sa.add(hgsettings3)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def admin_prompt(self, second=False, defaults={}):

        if not self.tests:

            import getpass

            # defaults

            username = defaults.get('username')

            password = defaults.get('password')

            email = defaults.get('email')

            def get_password():

                password = getpass.getpass('Specify admin password '

                                           '(min 6 chars):')

                confirm = getpass.getpass('Confirm password:')

                if password != confirm:

                    log.error('passwords mismatch')

                    return False

                if len(password) < 6:

                    log.error('password is to short use at least 6 characters')

                    return False

                return password

            if username is None:

                username = raw_input('Specify admin username:')

            if password is None:

                password = get_password()

                if not password:

                    #second try

                    password = get_password()

                    if not password:

                        sys.exit()

            if email is None:

                email = raw_input('Specify admin email:')

            self.create_user(username, password, email, True)

        else:

            log.info('creating admin and regular test users')

            from rhodecode.tests import TEST_USER_ADMIN_LOGIN, \

            TEST_USER_ADMIN_PASS, TEST_USER_ADMIN_EMAIL, \

            TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS, \

            TEST_USER_REGULAR_EMAIL, TEST_USER_REGULAR2_LOGIN, \

            TEST_USER_REGULAR2_PASS, TEST_USER_REGULAR2_EMAIL

            self.create_user(TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS,

                             TEST_USER_ADMIN_EMAIL, True)

            self.create_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,

                             TEST_USER_REGULAR_EMAIL, False)

            self.create_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS,

                             TEST_USER_REGULAR2_EMAIL, False)

    def create_ui_settings(self):

        """

        Creates ui settings, fills out hooks

        and disables dotencode

        """

        #HOOKS

        hooks1_key = RhodeCodeUi.HOOK_UPDATE

        hooks1_ = self.sa.query(RhodeCodeUi)\

            .filter(RhodeCodeUi.ui_key == hooks1_key).scalar()

        hooks1 = RhodeCodeUi() if hooks1_ is None else hooks1_

        hooks1.ui_section = 'hooks'

        hooks1.ui_key = hooks1_key

        hooks1.ui_value = 'hg update >&2'

        hooks1.ui_active = False

        self.sa.add(hooks1)

        hooks2_key = RhodeCodeUi.HOOK_REPO_SIZE

        hooks2_ = self.sa.query(RhodeCodeUi)\

            .filter(RhodeCodeUi.ui_key == hooks2_key).scalar()

        hooks2 = RhodeCodeUi() if hooks2_ is None else hooks2_

        hooks2.ui_section = 'hooks'

        hooks2.ui_key = hooks2_key

        hooks2.ui_value = 'python:rhodecode.lib.hooks.repo_size'

        self.sa.add(hooks2)

        hooks3 = RhodeCodeUi()

        hooks3.ui_section = 'hooks'

        hooks3.ui_key = RhodeCodeUi.HOOK_PUSH

        hooks3.ui_value = 'python:rhodecode.lib.hooks.log_push_action'

        self.sa.add(hooks3)

        hooks4 = RhodeCodeUi()

        hooks4.ui_section = 'hooks'

        hooks4.ui_key = RhodeCodeUi.HOOK_PRE_PUSH

        hooks4.ui_value = 'python:rhodecode.lib.hooks.pre_push'

        self.sa.add(hooks4)

        hooks5 = RhodeCodeUi()

        hooks5.ui_section = 'hooks'

        hooks5.ui_key = RhodeCodeUi.HOOK_PULL

        hooks5.ui_value = 'python:rhodecode.lib.hooks.log_pull_action'

        self.sa.add(hooks5)

        hooks6 = RhodeCodeUi()

        hooks6.ui_section = 'hooks'

        hooks6.ui_key = RhodeCodeUi.HOOK_PRE_PULL

        hooks6.ui_value = 'python:rhodecode.lib.hooks.pre_pull'

        self.sa.add(hooks6)

        # enable largefiles

        largefiles = RhodeCodeUi()

        largefiles.ui_section = 'extensions'

        largefiles.ui_key = 'largefiles'

        largefiles.ui_value = ''

        self.sa.add(largefiles)

        # enable hgsubversion disabled by default

        hgsubversion = RhodeCodeUi()

        hgsubversion.ui_section = 'extensions'

        hgsubversion.ui_key = 'hgsubversion'

        hgsubversion.ui_value = ''

        hgsubversion.ui_active = False

        self.sa.add(hgsubversion)

        # enable hggit disabled by default

        hggit = RhodeCodeUi()

        hggit.ui_section = 'extensions'

        hggit.ui_key = 'hggit'

        hggit.ui_value = ''

        hggit.ui_active = False

        self.sa.add(hggit)

    def create_ldap_options(self, skip_existing=False):

        """Creates ldap settings"""

        for k, v in [('ldap_active', 'false'), ('ldap_host', ''),

                    ('ldap_port', '389'), ('ldap_tls_kind', 'PLAIN'),

                    ('ldap_tls_reqcert', ''), ('ldap_dn_user', ''),

                    ('ldap_dn_pass', ''), ('ldap_base_dn', ''),

                    ('ldap_filter', ''), ('ldap_search_scope', ''),

                    ('ldap_attr_login', ''), ('ldap_attr_firstname', ''),

                    ('ldap_attr_lastname', ''), ('ldap_attr_email', '')]:

            if skip_existing and RhodeCodeSetting.get_by_name(k) != None:

                log.debug('Skipping option %s' % k)

                continue

            setting = RhodeCodeSetting(k, v)

            self.sa.add(setting)

    def fixup_groups(self):

        def_usr = User.get_by_username('default')

        for g in RepoGroup.query().all():

            g.group_name = g.get_new_name(g.name)

            self.sa.add(g)

            # get default perm

            default = UserRepoGroupToPerm.query()\

                .filter(UserRepoGroupToPerm.group == g)\

                .filter(UserRepoGroupToPerm.user == def_usr)\

                .scalar()

            if default is None:

                log.debug('missing default permission for group %s adding' % g)

                ReposGroupModel()._create_default_perms(g)

    def reset_permissions(self, username):

        """

        Resets permissions to default state, usefull when old systems had

        bad permissions, we must clean them up

        :param username:

        :type username:

        """

        default_user = User.get_by_username(username)

        if not default_user:

            return

        u2p = UserToPerm.query()\

            .filter(UserToPerm.user == default_user).all()

        fixed = False

        if len(u2p) != len(User.DEFAULT_PERMISSIONS):

            for p in u2p:

                Session().delete(p)

            fixed = True

            self.populate_default_permissions()

        return fixed

    def config_prompt(self, test_repo_path='', retries=3, defaults={}):

        _path = defaults.get('repos_location')

        if retries == 3:

            log.info('Setting up repositories config')

        if _path is not None:

            path = _path

        elif not self.tests and not test_repo_path:

            path = raw_input(

                 'Enter a valid absolute path to store repositories. '

                 'All repositories in that path will be added automatically:'

            )

        else:

            path = test_repo_path

        path_ok = True

        # check proper dir

        if not os.path.isdir(path):

            path_ok = False

            log.error('Given path %s is not a valid directory' % path)

        elif not os.path.isabs(path):

            path_ok = False

            log.error('Given path %s is not an absolute path' % path)

        # check write access

        elif not os.access(path, os.W_OK) and path_ok:

            path_ok = False

            log.error('No write permission to given path %s' % path)

        if retries == 0:

            sys.exit('max retries reached')

        if path_ok is False:

            retries -= 1

            return self.config_prompt(test_repo_path, retries)

        real_path = os.path.realpath(path)

        if real_path != path:

            if not ask_ok(('Path looks like a symlink, Rhodecode will store '

                           'given path as %s ? [y/n]') % (real_path)):

                log.error('Canceled by user')

                sys.exit(-1)

        return real_path

    def create_settings(self, path):

        self.create_ui_settings()

        #HG UI OPTIONS

        web1 = RhodeCodeUi()

        web1.ui_section = 'web'

        web1.ui_key = 'push_ssl'

        web1.ui_value = 'false'

        web2 = RhodeCodeUi()

        web2.ui_section = 'web'

        web2.ui_key = 'allow_archive'

        web2.ui_value = 'gz zip bz2'

        web3 = RhodeCodeUi()

        web3.ui_section = 'web'

        web3.ui_key = 'allow_push'

        web3.ui_value = '*'

        web4 = RhodeCodeUi()

        web4.ui_section = 'web'

        web4.ui_key = 'baseurl'

        web4.ui_value = '/'

        paths = RhodeCodeUi()

        paths.ui_section = 'paths'

        paths.ui_key = '/'

        paths.ui_value = path

        phases = RhodeCodeUi()

        phases.ui_section = 'phases'

        phases.ui_key = 'publish'

        phases.ui_value = False

        sett1 = RhodeCodeSetting('realm', 'RhodeCode authentication')

        sett2 = RhodeCodeSetting('title', 'RhodeCode')

        sett3 = RhodeCodeSetting('ga_code', '')

        sett4 = RhodeCodeSetting('show_public_icon', True)

        sett5 = RhodeCodeSetting('show_private_icon', True)

        sett6 = RhodeCodeSetting('stylify_metatags', False)

        self.sa.add(web1)

        self.sa.add(web2)

        self.sa.add(web3)

        self.sa.add(web4)

        self.sa.add(paths)

        self.sa.add(sett1)

        self.sa.add(sett2)

        self.sa.add(sett3)

        self.sa.add(sett4)

        self.sa.add(sett5)

        self.sa.add(sett6)

        self.create_ldap_options()

        log.info('created ui config')

    def create_user(self, username, password, email='', admin=False):

        log.info('creating user %s' % username)

        UserModel().create_or_update(username, password, email,

                                     firstname='RhodeCode', lastname='Admin',

                                     active=True, admin=admin)

    def create_default_user(self):

        log.info('creating default user')

        # create default user for handling default permissions.

        UserModel().create_or_update(username='default',

                              password=str(uuid.uuid1())[:8],

                              email='anonymous@rhodecode.org',

                              firstname='Anonymous', lastname='User')

    def create_permissions(self):

        # module.(access|create|change|delete)_[name]

        # module.(none|read|write|admin)

        for p in Permission.PERMS:

            if not Permission.get_by_key(p[0]):

                new_perm = Permission()

                new_perm.permission_name = p[0]

                new_perm.permission_longname = p[0]

                self.sa.add(new_perm)

    def populate_default_permissions(self):

        log.info('creating default user permissions')

        default_user = User.get_by_username('default')

        for def_perm in User.DEFAULT_PERMISSIONS:

            perm = self.sa.query(Permission)\

             .filter(Permission.permission_name == def_perm)\

             .scalar()

            if not perm:

                raise Exception(

                  'CRITICAL: permission %s not found inside database !!'

                  % def_perm

                )

            if not UserToPerm.query()\

                .filter(UserToPerm.permission == perm)\

                .filter(UserToPerm.user == default_user).scalar():

                reg_perm = UserToPerm()

                reg_perm.user = default_user

                reg_perm.permission = perm

                self.sa.add(reg_perm)

    def finish(self):

        """

        Function executed at the end of setup

        """

        if not __py_version__ >= (2, 6):

            notify('Python2.5 detected, please switch '

                   'egg:waitress#main -> egg:Paste#http '

                                    other_ref_type="tag",

                                    other_ref=tag2,

                                    ))

        response.mustcontain('%s@%s -> %s@%s' % (HG_REPO, tag1, HG_REPO, tag2))

        ## outgoing changesets between tags

        response.mustcontain('''<a href="/%s/changeset/17544fbfcd33ffb439e2b728b5d526b1ef30bfcf">r120:17544fbfcd33</a>''' % HG_REPO)

        response.mustcontain('''<a href="/%s/changeset/36e0fc9d2808c5022a24f49d6658330383ed8666">r119:36e0fc9d2808</a>''' % HG_REPO)

        response.mustcontain('''<a href="/%s/changeset/bb1a3ab98cc45cb934a77dcabf87a5a598b59e97">r118:bb1a3ab98cc4</a>''' % HG_REPO)

        response.mustcontain('''<a href="/%s/changeset/41fda979f02fda216374bf8edac4e83f69e7581c">r117:41fda979f02f</a>''' % HG_REPO)

        response.mustcontain('''<a href="/%s/changeset/9749bfbfc0d2eba208d7947de266303b67c87cda">r116:9749bfbfc0d2</a>''' % HG_REPO)

        response.mustcontain('''<a href="/%s/changeset/70d4cef8a37657ee4cf5aabb3bd9f68879769816">r115:70d4cef8a376</a>''' % HG_REPO)

        response.mustcontain('''<a href="/%s/changeset/c5ddebc06eaaba3010c2d66ea6ec9d074eb0f678">r112:c5ddebc06eaa</a>''' % HG_REPO)

        ## files diff

        response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--1c5cf9e91c12">docs/api/utils/index.rst</a></div>''' % (HG_REPO, tag1, tag2))

        response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--e3305437df55">test_and_report.sh</a></div>''' % (HG_REPO, tag1, tag2))

        response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--c8e92ef85cd1">.hgignore</a></div>''' % (HG_REPO, tag1, tag2))

        response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--6e08b694d687">.hgtags</a></div>''' % (HG_REPO, tag1, tag2))

        response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--2c14b00f3393">docs/api/index.rst</a></div>''' % (HG_REPO, tag1, tag2))

        response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--430ccbc82bdf">vcs/__init__.py</a></div>''' % (HG_REPO, tag1, tag2))

        response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--9c390eb52cd6">vcs/backends/hg.py</a></div>''' % (HG_REPO, tag1, tag2))

        response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--ebb592c595c0">vcs/utils/__init__.py</a></div>''' % (HG_REPO, tag1, tag2))

        response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--7abc741b5052">vcs/utils/annotate.py</a></div>''' % (HG_REPO, tag1, tag2))

        response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--2ef0ef106c56">vcs/utils/diffs.py</a></div>''' % (HG_REPO, tag1, tag2))

        response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--3150cb87d4b7">vcs/utils/lazy.py</a></div>''' % (HG_REPO, tag1, tag2))

    def test_index_branch(self):

        self.log_user()

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

                                    repo_name=HG_REPO,

                                    org_ref_type="branch",

                                    org_ref='default',

                                    other_ref_type="branch",

                                    other_ref='default',

                                    ))

        response.mustcontain('%s@default -> %s@default' % (HG_REPO, HG_REPO))

        # branch are equal

        response.mustcontain('<tr><td>No changesets</td></tr>')

    def test_compare_revisions(self):

        self.log_user()

        rev1 = '3d8f361e72ab'

        rev2 = 'b986218ba1c9'

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

                                    repo_name=HG_REPO,

                                    org_ref_type="rev",

                                    org_ref=rev1,

                                    other_ref_type="rev",

                                    other_ref=rev2,

                                    ))

        response.mustcontain('%s@%s -> %s@%s' % (HG_REPO, rev1, HG_REPO, rev2))

        ## outgoing changesets between those revisions

        response.mustcontain("""<a href="/%s/changeset/3d8f361e72ab303da48d799ff1ac40d5ac37c67e">r1:%s</a>""" % (HG_REPO, rev1))

        ## files

        response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--c8e92ef85cd1">.hgignore</a>""" % (HG_REPO, rev1, rev2))

    def test_compare_remote_repos(self):

        self.log_user()

        form_data = dict(

            repo_name=HG_FORK,

            repo_name_full=HG_FORK,

            repo_group=None,

            repo_type='hg',

            description='',

            private=False,

            copy_permissions=False,

            landing_rev='tip',

            update_after_clone=False,

            fork_parent_id=Repository.get_by_repo_name(HG_REPO),

        )

        RepoModel().create_fork(form_data, cur_user=TEST_USER_ADMIN_LOGIN)

        Session().commit()

        rev1 = '7d4bc8ec6be5'

        rev2 = '56349e29c2af'

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

                                    repo_name=HG_REPO,

                                    org_ref_type="rev",

                                    org_ref=rev1,

                                    other_ref_type="rev",

                                    other_ref=rev2,

                                    repo=HG_FORK

                                    ))

        try:

            response.mustcontain('%s@%s -> %s@%s' % (HG_REPO, rev1, HG_FORK, rev2))

            ## outgoing changesets between those revisions

            response.mustcontain("""<a href="/%s/changeset/7d4bc8ec6be56c0f10425afb40b6fc315a4c25e7">r6:%s</a>""" % (HG_REPO, rev1))

            response.mustcontain("""<a href="/%s/changeset/6fff84722075f1607a30f436523403845f84cd9e">r5:6fff84722075</a>""" % (HG_REPO))

            response.mustcontain("""<a href="/%s/changeset/2dda4e345facb0ccff1a191052dd1606dba6781d">r4:2dda4e345fac</a>""" % (HG_REPO))

            ## files

            response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--9c390eb52cd6">vcs/backends/hg.py</a>""" % (HG_REPO, rev1, rev2))

            response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--41b41c1f2796">vcs/backends/__init__.py</a>""" % (HG_REPO, rev1, rev2))

            response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--2f574d260608">vcs/backends/base.py</a>""" % (HG_REPO, rev1, rev2))

        finally:

            RepoModel().delete(HG_FORK)

    def test_compare_extra_commits(self):

        self.log_user()

        repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',

                                        description='diff-test',

                                        owner=TEST_USER_ADMIN_LOGIN)

        repo2 = RepoModel().create_repo(repo_name='one-fork', repo_type='hg',

                                        description='diff-test',

                                        owner=TEST_USER_ADMIN_LOGIN)

        Session().commit()

        r1_id = repo1.repo_id

        r1_name = repo1.repo_name

        r2_id = repo2.repo_id

        r2_name = repo2.repo_name

        #commit something !

        cs0 = ScmModel().create_node(

            repo=repo1.scm_instance, repo_name=r1_name,

            cs=EmptyChangeset(alias='hg'), user=TEST_USER_ADMIN_LOGIN,

            author=TEST_USER_ADMIN_LOGIN,

            message='commit1',

            content='line1',

            f_path='file1'

        )

        cs0_prim = ScmModel().create_node(

            repo=repo2.scm_instance, repo_name=r2_name,

            cs=EmptyChangeset(alias='hg'), user=TEST_USER_ADMIN_LOGIN,

            author=TEST_USER_ADMIN_LOGIN,

            message='commit1',

            content='line1',

            f_path='file1'

        )

        cs1 = ScmModel().commit_change(

            repo=repo2.scm_instance, repo_name=r2_name,

            cs=cs0_prim, user=TEST_USER_ADMIN_LOGIN, author=TEST_USER_ADMIN_LOGIN,

            message='commit2',

            content='line1\nline2',

            f_path='file1'

        )

        rev1 = 'default'

        rev2 = 'default'

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

                                    repo_name=r2_name,

                                    org_ref_type="branch",

                                    org_ref=rev1,

                                    other_ref_type="branch",

                                    other_ref=rev2,

                                    repo=r1_name

                                    ))

        try:

            response.mustcontain('%s@%s -> %s@%s' % (r2_name, rev1, r1_name, rev2))

            response.mustcontain("""<div class="message">commit2</div>""")

            response.mustcontain("""<a href="/%s/changeset/%s">r1:%s</a>""" % (r2_name, cs1.raw_id, cs1.short_id))

            ## files

            response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s#C--826e8142e6ba">file1</a>""" % (r2_name, rev1, rev2))

        finally:

            RepoModel().delete(r1_id)

            RepoModel().delete(r2_id)

    def test_org_repo_new_commits_after_forking(self):

        self.log_user()

        repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',

                                        description='diff-test',

                                        owner=TEST_USER_ADMIN_LOGIN)

        Session().commit()

        r1_id = repo1.repo_id

        r1_name = repo1.repo_name

        #commit something initially !

        cs0 = ScmModel().create_node(

            repo=repo1.scm_instance, repo_name=r1_name,

            cs=EmptyChangeset(alias='hg'), user=TEST_USER_ADMIN_LOGIN,

            author=TEST_USER_ADMIN_LOGIN,

            message='commit1',

            content='line1',

            f_path='file1'

        )

        Session().commit()

        self.assertEqual(repo1.scm_instance.revisions, [cs0.raw_id])

        #fork the repo1

        repo2 = RepoModel().create_repo(repo_name='one-fork', repo_type='hg',

                                description='compare-test',

                                clone_uri=repo1.repo_full_path,

                                owner=TEST_USER_ADMIN_LOGIN, fork_of='one')

        Session().commit()

        self.assertEqual(repo2.scm_instance.revisions, [cs0.raw_id])

        r2_id = repo2.repo_id

        r2_name = repo2.repo_name

        #make 3 new commits in fork

        cs1 = ScmModel().create_node(

            repo=repo2.scm_instance, repo_name=r2_name,

            cs=repo2.scm_instance[-1], user=TEST_USER_ADMIN_LOGIN,

            author=TEST_USER_ADMIN_LOGIN,

            message='commit1-fork',

            content='file1-line1-from-fork',

            f_path='file1-fork'

        )

        cs2 = ScmModel().create_node(

            repo=repo2.scm_instance, repo_name=r2_name,

            cs=cs1, user=TEST_USER_ADMIN_LOGIN,

            author=TEST_USER_ADMIN_LOGIN,

            message='commit2-fork',

            content='file2-line1-from-fork',

            f_path='file2-fork'

        )

        cs3 = ScmModel().create_node(

            repo=repo2.scm_instance, repo_name=r2_name,

            cs=cs2, user=TEST_USER_ADMIN_LOGIN,

            author=TEST_USER_ADMIN_LOGIN,

            message='commit3-fork',

            content='file3-line1-from-fork',

            f_path='file3-fork'

        )

        #compare !

        rev1 = 'default'

        rev2 = 'default'

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

                                    repo_name=r2_name,

                                    org_ref_type="branch",

                                    org_ref=rev1,

                                    other_ref_type="branch",

                                    other_ref=rev2,

                                    repo=r1_name,

                                    bundle=True,

                                    ))

        try:

            response.mustcontain('%s@%s -> %s@%s' % (r2_name, rev1, r1_name, rev2))

            response.mustcontain("""file1-line1-from-fork""")

            response.mustcontain("""file2-line1-from-fork""")

            response.mustcontain("""file3-line1-from-fork""")

            #add new commit into parent !

            cs0 = ScmModel().create_node(

                repo=repo1.scm_instance, repo_name=r1_name,

                cs=EmptyChangeset(alias='hg'), user=TEST_USER_ADMIN_LOGIN,

                author=TEST_USER_ADMIN_LOGIN,

                message='commit2',

                content='line1-from-new-parent',

                f_path='file2'

            )

            #compare !

            rev1 = 'default'

            rev2 = 'default'

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

                                        repo_name=r2_name,

                                        org_ref_type="branch",

                                        org_ref=rev1,

                                        other_ref_type="branch",

                                        other_ref=rev2,

                                        repo=r1_name,

                                        bundle=True,

                                        ))

            response.mustcontain('%s@%s -> %s@%s' % (r2_name, rev1, r1_name, rev2))

            response.mustcontain("""<a href="#">file2</a>""")  # new commit from parent

            response.mustcontain("""line1-from-new-parent""")

            response.mustcontain("""file1-line1-from-fork""")

            response.mustcontain("""file2-line1-from-fork""")

            response.mustcontain("""file3-line1-from-fork""")

        finally:

            RepoModel().delete(r2_id)

            RepoModel().delete(r1_id)

    def test_org_repo_new_commits_after_forking_simple_diff(self):

        self.log_user()

        repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',

                                        description='diff-test',

                                        owner=TEST_USER_ADMIN_LOGIN)

        Session().commit()

        r1_id = repo1.repo_id

        r1_name = repo1.repo_name