rmap.connect('reset_password', '%s/password_reset' % ADMIN_PREFIX,

                 controller='login', action='password_reset')

    rmap.connect('reset_password_confirmation',

                 '%s/password_reset_confirmation' % ADMIN_PREFIX,

                 controller='login', action='password_reset_confirmation')

    #FEEDS

    rmap.connect('rss_feed_home', '/{repo_name:.*?}/feed/rss',

                controller='feed', action='rss',

                conditions=dict(function=check_repo))

    rmap.connect('atom_feed_home', '/{repo_name:.*?}/feed/atom',

                controller='feed', action='atom',

                conditions=dict(function=check_repo))

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

    # REPOSITORY ROUTES

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

    rmap.connect('repo_creating_home', '/{repo_name:.*?}/repo_creating',

                controller='admin/repos', action='repo_creating')

    rmap.connect('repo_check_home', '/{repo_name:.*?}/crepo_check',

                controller='admin/repos', action='repo_check')

    rmap.connect('summary_home', '/{repo_name:.*?}',

                controller='summary',

                conditions=dict(function=check_repo))

    # must be here for proper group/repo catching

    rmap.connect('repos_group_home', '/{group_name:.*}',

                controller='admin/repo_groups', action="show_by_name",

                conditions=dict(function=check_group))

    rmap.connect('repo_stats_home', '/{repo_name:.*?}/statistics',

                controller='summary', action='statistics',

                conditions=dict(function=check_repo))

    rmap.connect('repo_size', '/{repo_name:.*?}/repo_size',

                controller='summary', action='repo_size',

                conditions=dict(function=check_repo))

    rmap.connect('repo_refs_data', '/{repo_name:.*?}/refs-data',

                 controller='home', action='repo_refs_data')

    rmap.connect('changeset_home', '/{repo_name:.*?}/changeset/{revision:.*}',

                controller='changeset', revision='tip',

                conditions=dict(function=check_repo))

    rmap.connect('changeset_children', '/{repo_name:.*?}/changeset_children/{revision}',

                controller='changeset', revision='tip', action="changeset_children",

                conditions=dict(function=check_repo))

    rmap.connect('changeset_parents', '/{repo_name:.*?}/changeset_parents/{revision}',

                controller='changeset', revision='tip', action="changeset_parents",

                conditions=dict(function=check_repo))

    # repo edit options

    rmap.connect("edit_repo", "/{repo_name:.*?}/settings",

                 controller='admin/repos', action="edit",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_perms", "/{repo_name:.*?}/settings/permissions",

                 controller='admin/repos', action="edit_permissions",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_perms_update", "/{repo_name:.*?}/settings/permissions",

                 controller='admin/repos', action="edit_permissions_update",

                 conditions=dict(method=["PUT"], function=check_repo))

    rmap.connect("edit_repo_perms_revoke", "/{repo_name:.*?}/settings/permissions/delete",

                 controller='admin/repos', action="edit_permissions_revoke",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_fields", "/{repo_name:.*?}/settings/fields",

                 controller='admin/repos', action="edit_fields",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect('create_repo_fields', "/{repo_name:.*?}/settings/fields/new",

                 controller='admin/repos', action="create_repo_field",

                 conditions=dict(method=["PUT"], function=check_repo))

    rmap.connect('delete_repo_fields', "/{repo_name:.*?}/settings/fields/{field_id}/delete",

                 controller='admin/repos', action="delete_repo_field",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_advanced", "/{repo_name:.*?}/settings/advanced",

                 controller='admin/repos', action="edit_advanced",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_advanced_locking", "/{repo_name:.*?}/settings/advanced/locking",

                 controller='admin/repos', action="edit_advanced_locking",

                 conditions=dict(method=["PUT"], function=check_repo))

    rmap.connect('toggle_locking', "/{repo_name:.*?}/settings/advanced/locking_toggle",

                 controller='admin/repos', action="toggle_locking",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_advanced_journal", "/{repo_name:.*?}/settings/advanced/journal",

                 controller='admin/repos', action="edit_advanced_journal",

                 conditions=dict(method=["PUT"], function=check_repo))

    rmap.connect("edit_repo_advanced_fork", "/{repo_name:.*?}/settings/advanced/fork",

                 controller='admin/repos', action="edit_advanced_fork",

    rmap.connect("edit_repo_caches", "/{repo_name:.*?}/settings/caches",

                 controller='admin/repos', action="edit_caches",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_caches", "/{repo_name:.*?}/settings/caches",

                 controller='admin/repos', action="edit_caches",

                 conditions=dict(method=["PUT"], function=check_repo))

    rmap.connect("edit_repo_remote", "/{repo_name:.*?}/settings/remote",

                 controller='admin/repos', action="edit_remote",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_remote", "/{repo_name:.*?}/settings/remote",

                 controller='admin/repos', action="edit_remote",

                 conditions=dict(method=["PUT"], function=check_repo))

    rmap.connect("edit_repo_statistics", "/{repo_name:.*?}/settings/statistics",

                 controller='admin/repos', action="edit_statistics",

                 conditions=dict(method=["GET"], function=check_repo))

    rmap.connect("edit_repo_statistics", "/{repo_name:.*?}/settings/statistics",

                 controller='admin/repos', action="edit_statistics",

                 conditions=dict(method=["PUT"], function=check_repo))

    #still working url for backward compat.

    rmap.connect('raw_changeset_home_depraced',

                 '/{repo_name:.*?}/raw-changeset/{revision}',

                 controller='changeset', action='changeset_raw',

                 revision='tip', conditions=dict(function=check_repo))

    ## new URLs

    rmap.connect('changeset_raw_home',

                 '/{repo_name:.*?}/changeset-diff/{revision}',

                 controller='changeset', action='changeset_raw',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_patch_home',

                 '/{repo_name:.*?}/changeset-patch/{revision}',

                 controller='changeset', action='changeset_patch',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_download_home',

                 '/{repo_name:.*?}/changeset-download/{revision}',

                 controller='changeset', action='changeset_download',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_comment',

                 '/{repo_name:.*?}/changeset-comment/{revision}',

                controller='changeset', revision='tip', action='comment',

                conditions=dict(function=check_repo))

    rmap.connect('changeset_comment_delete',

                 '/{repo_name:.*?}/changeset-comment/{comment_id}/delete',

                controller='changeset', action='delete_comment',

                conditions=dict(function=check_repo, method=["POST"]))

    rmap.connect('changeset_info', '/changeset_info/{repo_name:.*?}/{revision}',

                 controller='changeset', action='changeset_info')

    rmap.connect('compare_home',

                 '/{repo_name:.*?}/compare',

                 controller='compare', action='index',

                 conditions=dict(function=check_repo))

    rmap.connect('compare_url',

                 '/{repo_name:.*?}/compare/{org_ref_type}@{org_ref_name:.*?}...{other_ref_type}@{other_ref_name:.*?}',

                 controller='compare', action='compare',

                 conditions=dict(function=check_repo),

                 requirements=dict(

                            org_ref_type='(branch|book|tag|rev|__other_ref_type__)',

                            other_ref_type='(branch|book|tag|rev|__org_ref_type__)')

                 )

    rmap.connect('pullrequest_home',

                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',

                 action='index', conditions=dict(function=check_repo,

                                                 method=["GET"]))

    rmap.connect('pullrequest_repo_info',

                 '/{repo_name:.*?}/pull-request-repo-info',

                 controller='pullrequests', action='repo_info',

                 conditions=dict(function=check_repo, method=["GET"]))

    rmap.connect('pullrequest',

                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',

                 action='create', conditions=dict(function=check_repo,

                                                  method=["POST"]))

    rmap.connect('pullrequest_show',

                 '/{repo_name:.*?}/pull-request/{pull_request_id:\\d+}{extra:(/.*)?}', extra='',

                 controller='pullrequests',

                 action='show', conditions=dict(function=check_repo,

                                                method=["GET"]))

    rmap.connect('pullrequest_post',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

<h3>${_('Parent')}</h3>

<div class="form">

       ${h.select('id_fork_of','',c.repos_list,class_="medium")}

       ${h.submit('set_as_fork_%s' % c.repo_info.repo_name,_('Set'),class_="btn btn-small")}

       <div class="field" style="border:none;color:#888">

       <ul>

            <li>${_('''Manually set this repository as a fork of another from the list.''')}</li>

       </ul>

       </div>

</div>

${h.end_form()}

<script>

    $(document).ready(function(){

        $("#id_fork_of").select2({

            'dropdownAutoWidth': true

        });

    });

</script>

<h3>${_('Public Journal Visibility')}</h3>

${h.form(url('edit_repo_advanced_journal', repo_name=c.repo_info.repo_name), method='put')}

<div class="form">

  <div class="field">

  %if c.in_public_journal:

    <button class="btn btn-small" type="submit">

        <i class="icon-minus"></i>

        ${_('Remove from public journal')}

    </button>

  %else:

    <button class="btn btn-small" type="submit">

        <i class="icon-plus"></i>

        ${_('Add to Public Journal')}

    </button>

  %endif

  </div>

 <div class="field" style="border:none;color:#888">

 <ul>

      <li>${_('All actions done in this repository will be visible to everyone in the public journal.')}</li>

 </ul>

 </div>

</div>

${h.end_form()}

<h3>${_('Change Locking')}</h3>

${h.form(url('edit_repo_advanced_locking', repo_name=c.repo_info.repo_name), method='put')}

<div class="form">

      %if c.repo_info.locked[0]:

        ${h.hidden('set_unlock', '1')}

        <button class="btn btn-small" type="submit"

                onclick="return confirm('${_('Confirm to unlock repository.')}');">

            <i class="icon-lock-open-alt"></i>

            ${_('Unlock Repository')}

        </button>

       ${_('Locked by %s on %s') % (h.person_by_id(c.repo_info.locked[0]),h.fmt_date(h.time_to_datetime(c.repo_info.locked[1])))}

      %else:

        ${h.hidden('set_lock', '1')}

        <button class="btn btn-small" type="submit"

                onclick="return confirm('${_('Confirm to lock repository.')}');">

            <i class="icon-lock"></i>

            ${_('Lock Repository')}

        </button>

        ${_('Repository is not locked')}

      %endif

   <div class="field" style="border:none;color:#888">

   <ul>

        <li>${_('Force locking on the repository. Works only when anonymous access is disabled. Triggering a pull locks the repository.  The user who is pulling locks the repository; only the user who pulled and locked it can unlock it by doing a push.')}

        </li>

   </ul>

   </div>

</div>

${h.end_form()}

<h3>${_('Delete')}</h3>

${h.form(url('delete_repo', repo_name=c.repo_name))}

<div class="form">

    <button class="btn btn-small btn-danger" type="submit"

            onclick="return confirm('${_('Confirm to delete this repository: %s') % c.repo_name}');">

        <i class="icon-minus-circled"></i>

        ${_('Delete this Repository')}

    </button>

    %if c.repo_info.forks.count():

        ${ungettext('This repository has %s fork', 'This repository has %s forks', c.repo_info.forks.count()) % c.repo_info.forks.count()}

        <input type="radio" name="forks" value="detach_forks" checked="checked"/> <label for="forks">${_('Detach forks')}</label>

        <input type="radio" name="forks" value="delete_forks" /> <label for="forks">${_('Delete forks')}</label>

    %endif

    <div class="field" style="border:none;color:#888">

        <ul>

        <li>${_('The deleted repository will be moved away and hidden until the administrator expires it. The administrator can both permanently delete it or restore it.')}</li>

        </ul>

    </div>

</div>

${h.end_form()}

        # test if the repository is visible in the list ?

        response = self.app.get(url('summary_home', repo_name=repo_name))

        response.mustcontain(repo_name)

        response.mustcontain(self.REPO_TYPE)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(safe_str(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name_unicode)))

        except vcs.exceptions.VCSError:

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

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

            params={'_authentication_token': self.authentication_token()})

        self.checkSessionFlash(response, 'Deleted repository %s' % (repo_name_unicode))

        response.follow()

        #check if repo was deleted from db

        deleted_repo = Session().query(Repository) \

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

        assert deleted_repo == None

        assert os.path.isdir(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name_unicode)) == False

    def test_delete_repo_with_group(self):

        #TODO:

        pass

    def test_delete_browser_fakeout(self):

        response = self.app.post(url('delete_repo', repo_name=self.REPO),

                                 params=dict(_authentication_token=self.authentication_token()))

    def test_show(self):

        self.log_user()

        response = self.app.get(url('summary_home', repo_name=self.REPO))

    def test_edit(self):

        response = self.app.get(url('edit_repo', repo_name=self.REPO))

    def test_set_private_flag_sets_default_to_none(self):

        self.log_user()

        #initially repository perm should be read

        perm = _get_permission_for_user(user='default', repo=self.REPO)

        assert len(perm), 1

        assert perm[0].permission.permission_name == 'repository.read'

        assert Repository.get_by_repo_name(self.REPO).private == False

        response = self.app.post(url('update_repo', repo_name=self.REPO),

                        fixture._get_repo_create_params(repo_private=1,

                                                repo_name=self.REPO,

                                                repo_type=self.REPO_TYPE,

                                                user=TEST_USER_ADMIN_LOGIN,

                                                _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               msg='Repository %s updated successfully' % (self.REPO))

        assert Repository.get_by_repo_name(self.REPO).private == True

        #now the repo default permission should be None

        perm = _get_permission_for_user(user='default', repo=self.REPO)

        assert len(perm), 1

        assert perm[0].permission.permission_name == 'repository.none'

        response = self.app.post(url('update_repo', repo_name=self.REPO),

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=self.REPO,

                                                repo_type=self.REPO_TYPE,

                                                user=TEST_USER_ADMIN_LOGIN,

                                                _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               msg='Repository %s updated successfully' % (self.REPO))

        assert Repository.get_by_repo_name(self.REPO).private == False

        #we turn off private now the repo default permission should stay None

        perm = _get_permission_for_user(user='default', repo=self.REPO)

        assert len(perm), 1

        assert perm[0].permission.permission_name == 'repository.none'

        #update this permission back

        perm[0].permission = Permission.get_by_key('repository.read')

        Session().add(perm[0])

        Session().commit()

    def test_set_repo_fork_has_no_self_id(self):

        self.log_user()

        repo = Repository.get_by_repo_name(self.REPO)

        response = self.app.get(url('edit_repo_advanced', repo_name=self.REPO))

        opt = """<option value="%s">%s</option>""" % (repo.repo_id, self.REPO)

        response.mustcontain(no=[opt])

    def test_set_fork_of_other_repo(self):

        self.log_user()

        other_repo = u'other_%s' % self.REPO_TYPE

        fixture.create_repo(other_repo, repo_type=self.REPO_TYPE)

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(other_repo)

                                params=dict(id_fork_of=repo2.repo_id, _authentication_token=self.authentication_token()))

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(other_repo)

        self.checkSessionFlash(response,

            'Marked repository %s as fork of %s' % (repo.repo_name, repo2.repo_name))

        assert repo.fork == repo2

        response = response.follow()

        # check if given repo is selected

        opt = """<option value="%s" selected="selected">%s</option>""" % (

                    repo2.repo_id, repo2.repo_name)

        response.mustcontain(opt)

        fixture.destroy_repo(other_repo, forks='detach')

    def test_set_fork_of_other_type_repo(self):

        self.log_user()

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(self.OTHER_TYPE_REPO)

                                params=dict(id_fork_of=repo2.repo_id, _authentication_token=self.authentication_token()))

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(self.OTHER_TYPE_REPO)

        self.checkSessionFlash(response,

            'Cannot set repository as fork of repository with other type')

    def test_set_fork_of_none(self):

        self.log_user()

        ## mark it as None

                                params=dict(id_fork_of=None, _authentication_token=self.authentication_token()))

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(self.OTHER_TYPE_REPO)

        self.checkSessionFlash(response,

                               'Marked repository %s as fork of %s'

                               % (repo.repo_name, "Nothing"))

        assert repo.fork is None

    def test_set_fork_of_same_repo(self):

        self.log_user()

        repo = Repository.get_by_repo_name(self.REPO)

                                params=dict(id_fork_of=repo.repo_id, _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               'An error occurred during this operation')

    def test_create_on_top_level_without_permissions(self):

        usr = self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)

        # revoke

        user_model = UserModel()

        # disable fork and create on default user

        user_model.revoke_perm(User.DEFAULT_USER, 'hg.create.repository')

        user_model.grant_perm(User.DEFAULT_USER, 'hg.create.none')

        user_model.revoke_perm(User.DEFAULT_USER, 'hg.fork.repository')

        user_model.grant_perm(User.DEFAULT_USER, 'hg.fork.none')

        # disable on regular user

        user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.repository')

        user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.none')

        user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.repository')

        user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.none')

        Session().commit()

        user = User.get(usr['user_id'])

        repo_name = self.NEW_REPO + u'no_perms'

        description = 'description for newly created repo'

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                _authentication_token=self.authentication_token()))

        response.mustcontain('<span class="error-message">Invalid value</span>')

        RepoModel().delete(repo_name)

        Session().commit()

    @mock.patch.object(RepoModel, '_create_filesystem_repo', error_function)

    def test_create_repo_when_filesystem_op_fails(self):

        self.log_user()

        repo_name = self.NEW_REPO

        description = 'description for newly created repo'

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               'Error creating repository %s' % repo_name)

        # repo must not be in db

        repo = Repository.get_by_repo_name(repo_name)

        assert repo == None

        # repo must not be in filesystem !

        assert not os.path.isdir(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name))

class TestAdminReposControllerGIT(_BaseTestCase):

    REPO = GIT_REPO

    REPO_TYPE = 'git'

    NEW_REPO = NEW_GIT_REPO

    OTHER_TYPE_REPO = HG_REPO

    OTHER_TYPE = 'hg'

class TestAdminReposControllerHG(_BaseTestCase):

    REPO = HG_REPO

    REPO_TYPE = 'hg'

    NEW_REPO = NEW_HG_REPO

    OTHER_TYPE_REPO = GIT_REPO

    OTHER_TYPE = 'git'

    def test_permanent_url_protocol_access(self):

        with pytest.raises(Exception) as e:

            self.app.get(url('summary_home', repo_name='_1'), extra_environ={'HTTP_ACCEPT': 'application/mercurial'})

        assert 'Unable to detect pull/push action' in str(e)