old_pull_request.title)]

        if lost:

            infos.append(_('Missing changesets since the previous iteration:'))

            for r in old_pull_request.revisions:

                if r in lost:

                    rev_desc = org_repo.get_changeset(r).message.split('\n')[0]

                    infos.append('  %s %s' % (h.short_id(r), rev_desc))

        if new_revisions:

            infos.append(_('New changesets on %s %s since the previous iteration:') % (org_ref_type, org_ref_name))

            for r in reversed(revisions):

                if r in new_revisions:

                    rev_desc = org_repo.get_changeset(r).message.split('\n')[0]

                    infos.append('  %s %s' % (h.short_id(r), h.shorter(rev_desc, 80)))

            if ancestor_rev == other_rev:

                infos.append(_("Ancestor didn't change - diff since previous iteration:"))

                infos.append(h.canonical_url('compare_url',

                                 repo_name=org_repo.repo_name, # other_repo is always same as repo_name

                                 org_ref_type='rev', org_ref_name=h.short_id(org_rev), # use old org_rev as base

                                 other_ref_type='rev', other_ref_name=h.short_id(new_org_rev),

                                 )) # note: linear diff, merge or not doesn't matter

            else:

                infos.append(_('This iteration is based on another %s revision and there is no simple diff.') % other_ref_name)

        else:

           infos.append(_('No changes found on %s %s since previous iteration.') % (org_ref_type, org_ref_name))

           # TODO: fail?

        # hack: ancestor_rev is not an other_ref but we want to show the

        # requested destination and have the exact ancestor

        new_other_ref = '%s:%s:%s' % (other_ref_type, other_ref_name, ancestor_rev)

        new_org_ref = '%s:%s:%s' % (org_ref_type, org_ref_name, new_org_rev)

        try:

            title, old_v = re.match(r'(.*)\(v(\d+)\)\s*$', title).groups()

            v = int(old_v) + 1

        except (AttributeError, ValueError):

            v = 2

        title = '%s (v%s)' % (title.strip(), v)

        # using a mail-like separator, insert new iteration info in description with latest first

        descriptions = description.replace('\r\n', '\n').split('\n-- \n', 1)

        description = descriptions[0].strip() + '\n\n-- \n' + '\n'.join(infos)

        if len(descriptions) > 1:

            description += '\n\n' + descriptions[1].strip()

        try:

            pull_request = PullRequestModel().create(

                self.authuser.user_id,

                old_pull_request.org_repo.repo_name, new_org_ref,

                old_pull_request.other_repo.repo_name, new_other_ref,

                revisions, reviewer_ids, title, description

            )

        except UserInvalidException as u:

            h.flash(_('Invalid reviewer "%s" specified') % u, category='error')

            raise HTTPBadRequest()

        except Exception:

            h.flash(_('Error occurred while creating pull request'),

                    category='error')

            log.error(traceback.format_exc())

            raise HTTPFound(location=old_pull_request.url())

        ChangesetCommentsModel().create(

            text=_('Closed, next iteration: %s .') % pull_request.url(canonical=True),

            repo=old_pull_request.other_repo_id,

            author=c.authuser.user_id,

            pull_request=old_pull_request.pull_request_id,

            closing_pr=True)

        PullRequestModel().close_pull_request(old_pull_request.pull_request_id)

        Session().commit()

        h.flash(_('New pull request iteration created'),

                category='success')

        raise HTTPFound(location=pull_request.url())

    # pullrequest_post for PR editing

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    def post(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        assert pull_request.other_repo.repo_name == repo_name

        #only owner or admin can update it

        owner = pull_request.owner_id == c.authuser.user_id

        repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)

        if not (h.HasPermissionAny('hg.admin')() or repo_admin or owner):

            raise HTTPForbidden()

        _form = PullRequestPostForm()().to_python(request.POST)

        reviewer_ids = set(int(s) for s in _form['review_members'])

        if _form['updaterev']:

            return self.create_new_iteration(pull_request,

                                      _form['updaterev'],

                                      _form['pullrequest_title'],

                                      _form['pullrequest_desc'],

                                      reviewer_ids)

        old_description = pull_request.description

        pull_request.title = _form['pullrequest_title']

        pull_request.description = _form['pullrequest_desc'].strip() or _('No description')

        pull_request.owner = User.get_by_username(_form['owner'])

        user = User.get(c.authuser.user_id)

        try:

            PullRequestModel().mention_from_description(user, pull_request, old_description)

            PullRequestModel().update_reviewers(user, pull_request_id, reviewer_ids)

        except UserInvalidException as u:

            h.flash(_('Invalid reviewer "%s" specified') % u, category='error')

            raise HTTPBadRequest()

        Session().commit()

        h.flash(_('Pull request updated'), category='success')

        raise HTTPFound(location=pull_request.url())

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def delete(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        #only owner can delete it !

        if pull_request.owner_id == c.authuser.user_id:

            PullRequestModel().delete(pull_request)

            Session().commit()

            h.flash(_('Successfully deleted pull request'),

                    category='success')

            raise HTTPFound(location=url('my_pullrequests'))

        raise HTTPForbidden()

    @LoginRequired()

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

                                   'repository.admin')

    def show(self, repo_name, pull_request_id, extra=None):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

        c.pull_request = PullRequest.get_or_404(pull_request_id)

        c.allowed_to_change_status = self._get_is_allowed_change_status(c.pull_request)

        cc_model = ChangesetCommentsModel()

        cs_model = ChangesetStatusModel()

        # pull_requests repo_name we opened it against

        # ie. other_repo must match

        if repo_name != c.pull_request.other_repo.repo_name:

            raise HTTPNotFound

        # load compare data into template context

        c.cs_repo = c.pull_request.org_repo

        (c.cs_ref_type,

         c.cs_ref_name,

         c.cs_rev) = c.pull_request.org_ref.split(':')

        c.a_repo = c.pull_request.other_repo

        (c.a_ref_type,

         c.a_ref_name,

         c.a_rev) = c.pull_request.other_ref.split(':') # other_rev is ancestor

        org_scm_instance = c.cs_repo.scm_instance # property with expensive cache invalidation check!!!

        c.cs_repo = c.cs_repo

        try:

            c.cs_ranges = [org_scm_instance.get_changeset(x)

                           for x in c.pull_request.revisions]

        except ChangesetDoesNotExistError:

            c.cs_ranges = []

            h.flash(_('Revision %s not found in %s') % (x, c.cs_repo.repo_name),

                'error')

        c.cs_ranges_org = None # not stored and not important and moving target - could be calculated ...

        revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

        c.jsdata = json.dumps(graph_data(org_scm_instance, revs))

        c.is_range = False

        try:

            if c.a_ref_type == 'rev': # this looks like a free range where target is ancestor

                cs_a = org_scm_instance.get_changeset(c.a_rev)

                root_parents = c.cs_ranges[0].parents

                c.is_range = cs_a in root_parents

                #c.merge_root = len(root_parents) > 1 # a range starting with a merge might deserve a warning

        except ChangesetDoesNotExistError: # probably because c.a_rev not found

            pass

        except IndexError: # probably because c.cs_ranges is empty, probably because revisions are missing

            pass

        avail_revs = set()

        avail_show = []

        c.cs_branch_name = c.cs_ref_name

def AuthSettingsForm(current_active_modules):

    class _AuthSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        auth_plugins = All(v.ValidAuthPlugins(),

                           v.UniqueListFromString()(not_empty=True))

        def __init__(self, *args, **kwargs):

            # The auth plugins tell us what form validators they use

            if current_active_modules:

                import kallithea.lib.auth_modules

                from kallithea.lib.auth_modules import LazyFormencode

                for module in current_active_modules:

                    plugin = kallithea.lib.auth_modules.loadplugin(module)

                    plugin_name = plugin.name

                    for sv in plugin.plugin_settings():

                        newk = "auth_%s_%s" % (plugin_name, sv["name"])

                        # can be a LazyFormencode object from plugin settings

                        validator = sv["validator"]

                        if isinstance(validator, LazyFormencode):

                            validator = validator()

                        #init all lazy validators from formencode.All

                        if isinstance(validator, All):

                            init_validators = []

                            for validator in validator.validators:

                                if isinstance(validator, LazyFormencode):

                                    validator = validator()

                                init_validators.append(validator)

                            validator.validators = init_validators

                        self.add_field(newk, validator)

            formencode.Schema.__init__(self, *args, **kwargs)

    return _AuthSettingsForm

def LdapSettingsForm(tls_reqcert_choices, search_scope_choices,

                     tls_kind_choices):

    class _LdapSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        #pre_validators = [LdapLibValidator]

        ldap_active = v.StringBoolean(if_missing=False)

        ldap_host = v.UnicodeString(strip=True,)

        ldap_port = v.Number(strip=True,)

        ldap_tls_kind = v.OneOf(tls_kind_choices)

        ldap_tls_reqcert = v.OneOf(tls_reqcert_choices)

        ldap_dn_user = v.UnicodeString(strip=True,)

        ldap_dn_pass = v.UnicodeString(strip=True,)

        ldap_base_dn = v.UnicodeString(strip=True,)

        ldap_filter = v.UnicodeString(strip=True,)

        ldap_search_scope = v.OneOf(search_scope_choices)

        ldap_attr_login = v.AttrLoginValidator()(not_empty=True)

        ldap_attr_firstname = v.UnicodeString(strip=True,)

        ldap_attr_lastname = v.UnicodeString(strip=True,)

        ldap_attr_email = v.UnicodeString(strip=True,)

    return _LdapSettingsForm

def UserExtraEmailForm():

    class _UserExtraEmailForm(formencode.Schema):

        email = All(v.UniqSystemEmail(), v.Email(not_empty=True))

    return _UserExtraEmailForm

def UserExtraIpForm():

    class _UserExtraIpForm(formencode.Schema):

        ip = v.ValidIp()(not_empty=True)

    return _UserExtraIpForm

def PullRequestForm(repo_id):

    class _PullRequestForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        org_repo = v.UnicodeString(strip=True, required=True)

        org_ref = v.UnicodeString(strip=True, required=True)

        other_repo = v.UnicodeString(strip=True, required=True)

        other_ref = v.UnicodeString(strip=True, required=True)

        pullrequest_title = v.UnicodeString(strip=True, required=True)

        pullrequest_desc = v.UnicodeString(strip=True, required=False)

    return _PullRequestForm

def PullRequestPostForm():

    class _PullRequestPostForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        pullrequest_title = v.UnicodeString(strip=True, required=True)

        pullrequest_desc = v.UnicodeString(strip=True, required=False)

        review_members = v.Set()

        updaterev = v.UnicodeString(strip=True, required=False, if_missing=None)

        owner = All(v.UnicodeString(strip=True, required=True),

                    v.ValidRepoUser())

    return _PullRequestPostForm

def GistForm(lifetime_options):

    class _GistForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        filename = All(v.BasePath()(),

                       v.UnicodeString(strip=True, required=False))

        description = v.UnicodeString(required=False, if_missing=u'')

        lifetime = v.OneOf(lifetime_options)

        mimetype = v.UnicodeString(required=False, if_missing=None)

        content = v.UnicodeString(required=True, not_empty=True)

        public = v.UnicodeString(required=False, if_missing=u'')

        private = v.UnicodeString(required=False, if_missing=u'')

    return _GistForm

          <div class="label-summary">

              <label>${_('Pull changes')}:</label>

          </div>

          <div class="input">

            %if c.cs_ranges:

              <div>

               ## TODO: use cs_ranges[-1] or org_ref_parts[1] in both cases?

               %if h.is_hg(c.pull_request.org_repo):

                 <span style="font-family: monospace">hg pull ${c.pull_request.org_repo.clone_url()} -r ${h.short_id(c.cs_ranges[-1].raw_id)}</span>

               %elif h.is_git(c.pull_request.org_repo):

                 <span style="font-family: monospace">git pull ${c.pull_request.org_repo.clone_url()} ${c.pull_request.org_ref_parts[1]}</span>

               %endif

              </div>

            %endif

          </div>

        </div>

        <div class="field">

          <div class="label-summary">

              <label>${_('Created on')}:</label>

          </div>

          <div class="input">

              <div>${h.fmt_date(c.pull_request.created_on)}</div>

          </div>

        </div>

        <div class="field">

          <div class="label-summary">

              <label>${_('Owner')}:</label>

          </div>

          <div class="input pr-not-edit">

                  ${h.gravatar_div(c.pull_request.owner.email, size=20)}

                  <span>${c.pull_request.owner.full_name_and_username}</span><br/>

                  <span><a href="mailto:${c.pull_request.owner.email}">${c.pull_request.owner.email}</a></span><br/>

          </div>

          <div class="input pr-do-edit ac" style="display:none">

               ${h.text('owner', class_="large", value=c.pull_request.owner.username, placeholder=_('Username'))}

               <div id="owner_completion_container"></div>

          </div>

        </div>

        <div class="field">

            <div class="label-summary">

              <label>${_('Next iteration')}:</label>

            </div>

            <div class="input">

              <div class="msg-div">${c.update_msg}</div>

              %if c.avail_revs:

              <div id="updaterevs" style="max-height:200px; overflow-y:auto; overflow-x:hidden; margin-bottom: 10px; padding: 1px 0">

                <div style="height:0">

                  <canvas id="avail_graph_canvas" style="width:0"></canvas>

                </div>

                <table id="updaterevs-table" class="noborder" style="padding-left:50px">

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

                    <tr id="chg_available_${cnt+1}" class="${'mergerow' if len(cs.parents) > 1 and not (editable and cs.revision in c.avail_revs) else ''}">

                      %if c.cs_ranges and cs.revision == c.cs_ranges[-1].revision:

                        <td>

                          %if editable:

                            ${h.radio(name='updaterev', value='', checked=True)}

                          %endif

                        </td>

                        <td colspan="4">${_("Current revision - no change")}</td>

                      %else:

                        <td>

                          %if editable and cs.revision in c.avail_revs:

                            ${h.radio(name='updaterev', value=cs.raw_id)}

                          %endif

                        </td>

                        <td style="width: 120px"><span class="tooltip" title="${h.age(cs.date)}">${cs.date}</span></td>

                        <td>${h.link_to(h.show_id(cs),h.url('changeset_home',repo_name=c.cs_repo.repo_name,revision=cs.raw_id), class_='changeset_hash')}</td>

                        <td>

                          <div style="float: right; margin-top: -4px;">

                            %for tag in cs.tags:

                              <div class="tagtag" title="${_('Tag %s') % tag}">

                                ${h.link_to(tag,h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}

                              </div>

                            %endfor

                          </div>

                          <div class="message" style="white-space:normal; height:1.1em; max-width: 500px; padding:0">${h.urlify_text(cs.message, c.repo_name)}</div>

                        </td>

                      %endif

                    </tr>

                  %endfor

                </table>

              </div>

              <div class="msg-div">(${_("Pull request iterations do not change content once created. Select a revision and save to make a new iteration.")})</div>

              %endif

              <div class="msg-div">${c.update_msg_other}</div>

            </div>

        </div>

      </div>

    </div>

    ## REVIEWERS

    <div style="float:left; border-left:1px dashed #eee">

        <div class="pr-details-title">${_('Pull Request Reviewers')}</div>

        <div id="reviewers" style="padding:0px 0px 5px 10px">

          ## members goes here !

          <div>

            <ul id="review_members">

            %for member,status in c.pull_request_reviewers:

              ## WARNING: the HTML below is duplicate with

              ## kallithea/public/js/base.js

              ## If you change something here it should be reflected in the template too.

              <li id="reviewer_${member.user_id}">

                <div class="reviewers_member">

                    <div class="reviewer_status tooltip" title="${h.changeset_status_lbl(status)}">

                      <i class="icon-circle changeset-status-${status}"></i>

                    </div>

                  ${h.gravatar_div(member.email, size=14, div_class="reviewer_gravatar gravatar")}

                  <div style="float:left;">

                    ${member.full_name_and_username}

                    %if c.pull_request.owner_id == member.user_id:

                      (${_('Owner')})

                    %endif

                  </div>

                  <input type="hidden" value="${member.user_id}" name="review_members" />

                  %if editable:

                  <div class="reviewer_member_remove action_button" onclick="removeReviewMember(${member.user_id})" title="${_('Remove reviewer')}">

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

                  </div>

                  %endif

                </div>

              </li>

            %endfor

            </ul>

          </div>

          %if editable:

          <div class='ac'>

            <div class="reviewer_ac">

               ${h.text('user', class_='yui-ac-input',placeholder=_('Type name of reviewer to add'))}

               <div id="reviewers_container"></div>

            </div>

          </div>

          %endif

        </div>

        %if not c.pull_request_reviewers:

        <div class="pr-details-title">${_('Potential Reviewers')}</div>

        <div style="margin: 10px 0 10px 10px; max-width: 250px">

          <div>

            ${_('Click to add the repository owner as reviewer:')}

          </div>

          <ul style="margin-top: 10px">

            %for u in [c.pull_request.other_repo.owner]:

              <li>

                <a class="missing_reviewer missing_reviewer_${u.user_id}"

                  user_id="${u.user_id}"

                  fname="${u.name}"

                  lname="${u.lastname}"

                  nname="${u.username}"

                  gravatar_lnk="${h.gravatar_url(u.email, size=28, default='default')}"

                  gravatar_size="14"

                  title="Click to add reviewer to the list, then Save Changes.">${u.full_name}</a>

              </li>

            %endfor

          </ul>

        </div>

        %endif

    </div>

    <div class="form" style="clear:both">

      <div class="fields">

        %if editable:

          <div class="buttons">

            ${h.submit('pr-form-save',_('Save Changes'),class_="btn btn-default btn-sm")}

            ${h.submit('pr-form-clone',_('Create New Iteration with Changes'),class_="btn btn-default btn-sm",disabled='disabled')}

            ${h.reset('pr-form-reset',_('Cancel Changes'),class_="btn btn-default btn-sm")}

          </div>

        %endif

      </div>

    </div>

  ${h.end_form()}

</div>

<div class="panel panel-primary">

    <div class="panel-heading">

      <div class="breadcrumbs">${_('Pull Request Content')}</div>

    </div>

    <div class="table">

          <div id="changeset_compare_view_content">

              <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">

                  ${comment.comment_count(c.inline_cnt, len(c.comments))}

              </div>

              ##CS

              <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">

                ${ungettext('Showing %s commit','Showing %s commits', len(c.cs_ranges)) % len(c.cs_ranges)}

              </div>

              <%include file="/compare/compare_cs.html" />

              <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">

              ${_('Common ancestor')}:

              ${h.link_to(h.short_id(c.a_rev),h.url('changeset_home',repo_name=c.a_repo.repo_name,revision=c.a_rev), class_="changeset_hash")}

              </div>

              ## FILES

import re

from kallithea.tests.base import *

from kallithea.tests.fixture import Fixture

from kallithea.model.db import User

from kallithea.model.meta import Session

from kallithea.controllers.pullrequests import PullrequestsController

fixture = Fixture()

class TestPullrequestsController(TestController):

    def test_index(self):

        self.log_user()

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

                                    repo_name=HG_REPO))

    def test_create_trivial(self):

        self.log_user()

        response = self.app.post(url(controller='pullrequests', action='create',

                                     repo_name=HG_REPO),

                                 {'org_repo': HG_REPO,

                                  'org_ref': 'branch:default:default',

                                  'other_repo': HG_REPO,

                                  'other_ref': 'branch:default:default',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  '_authentication_token': self.authentication_token(),

                                 },

                                 status=302)

        response = response.follow()

        assert response.status == '200 OK'

        response.mustcontain('This pull request has already been merged to default.')

    def test_update_reviewers(self):

        self.log_user()

        regular_user = User.get_by_username(TEST_USER_REGULAR_LOGIN)

        regular_user2 = User.get_by_username(TEST_USER_REGULAR2_LOGIN)

        # create initial PR

        response = self.app.post(url(controller='pullrequests', action='create',

                                     repo_name=HG_REPO),

                                 {'org_repo': HG_REPO,

                                  'org_ref': 'branch:default:default',

                                  'other_repo': HG_REPO,

                                  'other_ref': 'branch:default:default',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  '_authentication_token': self.authentication_token(),

                                 },

                                 status=302)

        pull_request1_id = re.search('/pull-request/(\d+)/', response.location).group(1)

        assert response.location == 'http://localhost/%s/pull-request/%s/_/title' % (HG_REPO, pull_request1_id)

        # create new iteration

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

                                     repo_name=HG_REPO, pull_request_id=pull_request1_id),

                                 {

                                  'updaterev': 'default',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  'owner': TEST_USER_ADMIN_LOGIN,

                                  '_authentication_token': self.authentication_token(),

                                  'review_members': [regular_user.user_id],

                                 },

                                 status=302)

        pull_request2_id = re.search('/pull-request/(\d+)/', response.location).group(1)

        assert pull_request2_id != pull_request1_id

        assert response.location == 'http://localhost/%s/pull-request/%s/_/title_v2' % (HG_REPO, pull_request2_id)

        response = response.follow()

        # verify reviewer was added

        response.mustcontain('<input type="hidden" value="%s" name="review_members" />' % regular_user.user_id)

        # update without creating new iteration

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

                                     repo_name=HG_REPO, pull_request_id=pull_request2_id),

                                 {

                                  'pullrequest_title': 'Title',

                                  'pullrequest_desc': 'description',

                                  'owner': TEST_USER_ADMIN_LOGIN,

                                  '_authentication_token': self.authentication_token(),

                                 },

                                 status=302)

        assert response.location == 'http://localhost/%s/pull-request/%s/_/Title' % (HG_REPO, pull_request2_id)

        response = response.follow()

        # verify reviewers were added / removed

        response.mustcontain(no='<input type="hidden" value="%s" name="review_members" />' % regular_user.user_id)

        response.mustcontain('<input type="hidden" value="%s" name="review_members" />' % regular_user2.user_id)

    def test_update_with_invalid_reviewer(self):

        invalid_user_id = 99999

        self.log_user()

        # create a valid pull request

        response = self.app.post(url(controller='pullrequests', action='create',

                                     repo_name=HG_REPO),

                                 {

                                  'org_repo': HG_REPO,

                                  'org_ref': 'branch:default:default',

                                  'other_repo': HG_REPO,

                                  'other_ref': 'branch:default:default',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  '_authentication_token': self.authentication_token(),

                                 },

                                status=302)

        # location is of the form:

        # http://localhost/vcs_test_hg/pull-request/54/_/title

        m = re.search('/pull-request/(\d+)/', response.location)

        assert m != None

        pull_request_id = m.group(1)

        # update it

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

                                     repo_name=HG_REPO, pull_request_id=pull_request_id),

                                 {

                                  'updaterev': 'default',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  'owner': TEST_USER_ADMIN_LOGIN,

                                  '_authentication_token': self.authentication_token(),

                                  'review_members': [str(invalid_user_id)],

                                 },

                                 status=400)

        response.mustcontain('Invalid reviewer "%s" specified' % invalid_user_id)

    def test_edit_with_invalid_reviewer(self):

        invalid_user_id = 99999

        self.log_user()

        # create a valid pull request

        response = self.app.post(url(controller='pullrequests', action='create',

                                     repo_name=HG_REPO),

                                 {

                                  'org_repo': HG_REPO,

                                  'org_ref': 'branch:default:default',

                                  'other_repo': HG_REPO,

                                  'other_ref': 'branch:default:default',

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  '_authentication_token': self.authentication_token(),

                                 },

                                status=302)

        # location is of the form:

        # http://localhost/vcs_test_hg/pull-request/54/_/title

        m = re.search('/pull-request/(\d+)/', response.location)

        assert m != None

        pull_request_id = m.group(1)

        # edit it

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

                                     repo_name=HG_REPO, pull_request_id=pull_request_id),

                                 {

                                  'pullrequest_title': 'title',

                                  'pullrequest_desc': 'description',

                                  'owner': TEST_USER_ADMIN_LOGIN,

                                  '_authentication_token': self.authentication_token(),

                                  'review_members': [str(invalid_user_id)],

                                 },

                                 status=400)

        response.mustcontain('Invalid reviewer "%s" specified' % invalid_user_id)

class TestPullrequestsGetRepoRefs(TestController):

    def setup_method(self, method):

        self.main = fixture.create_repo(u'main', repo_type='hg')

        Session.commit()

        self.c = PullrequestsController()

    def teardown_method(self, method):

        fixture.destroy_repo(u'main')

        Session.commit()

        Session.remove()

    def test_repo_refs_empty_repo(self):

        # empty repo with no commits, no branches, no bookmarks, just one tag

        refs, default = self.c._get_repo_refs(self.main.scm_instance)

        assert default == 'tag:null:0000000000000000000000000000000000000000'

    def test_repo_refs_one_commit_no_hints(self):

        cs0 = fixture.commit_change(self.main.repo_name, filename='file1',

                content='line1\n', message='commit1', vcs_type='hg',

                parent=None, newfile=True)

        refs, default = self.c._get_repo_refs(self.main.scm_instance)

        assert default == 'branch:default:%s' % cs0.raw_id