|
|
# Copyright (C) 2010-2023 RhodeCode GmbH
|
|
|
#
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
|
# it under the terms of the GNU Affero General Public License, version 3
|
|
|
# (only), as published by the Free Software Foundation.
|
|
|
#
|
|
|
# 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 Affero General Public License
|
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
#
|
|
|
# This program is dual-licensed. If you wish to learn more about the
|
|
|
# RhodeCode Enterprise Edition, including its added features, Support services,
|
|
|
# and proprietary license terms, please see https://rhodecode.com/licenses/
|
|
|
import mock
|
|
|
import pytest
|
|
|
|
|
|
import rhodecode
|
|
|
from rhodecode.lib import helpers as h
|
|
|
from rhodecode.lib.vcs.backends.base import MergeResponse, MergeFailureReason, Reference
|
|
|
from rhodecode.lib.vcs.nodes import FileNode
|
|
|
from rhodecode.lib.ext_json import json
|
|
|
from rhodecode.model.changeset_status import ChangesetStatusModel
|
|
|
from rhodecode.model.db import (
|
|
|
PullRequest,
|
|
|
ChangesetStatus,
|
|
|
UserLog,
|
|
|
Notification,
|
|
|
ChangesetComment,
|
|
|
Repository,
|
|
|
)
|
|
|
from rhodecode.model.meta import Session
|
|
|
from rhodecode.model.pull_request import PullRequestModel
|
|
|
from rhodecode.model.user import UserModel
|
|
|
from rhodecode.model.comment import CommentsModel
|
|
|
from rhodecode.tests import (
|
|
|
assert_session_flash,
|
|
|
TEST_USER_ADMIN_LOGIN,
|
|
|
TEST_USER_REGULAR_LOGIN,
|
|
|
)
|
|
|
from rhodecode.tests.fixture_mods.fixture_utils import PRTestUtility
|
|
|
from rhodecode.tests.routes import route_path
|
|
|
|
|
|
|
|
|
@pytest.mark.usefixtures("app", "autologin_user")
|
|
|
@pytest.mark.backends("git", "hg")
|
|
|
class TestPullrequestsView(object):
|
|
|
def test_index(self, backend):
|
|
|
self.app.get(route_path("pullrequest_new", repo_name=backend.repo_name))
|
|
|
|
|
|
def test_option_menu_create_pull_request_exists(self, backend):
|
|
|
repo_name = backend.repo_name
|
|
|
response = self.app.get(h.route_path("repo_summary", repo_name=repo_name))
|
|
|
|
|
|
create_pr_link = '<a href="%s">Create Pull Request</a>' % route_path(
|
|
|
"pullrequest_new", repo_name=repo_name
|
|
|
)
|
|
|
response.mustcontain(create_pr_link)
|
|
|
|
|
|
def test_create_pr_form_with_raw_commit_id(self, backend):
|
|
|
repo = backend.repo
|
|
|
|
|
|
self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_new",
|
|
|
repo_name=repo.repo_name,
|
|
|
commit=repo.get_commit().raw_id,
|
|
|
),
|
|
|
status=200,
|
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize("pr_merge_enabled", [True, False])
|
|
|
@pytest.mark.parametrize("range_diff", ["0", "1"])
|
|
|
def test_show(self, pr_util, pr_merge_enabled, range_diff):
|
|
|
pull_request = pr_util.create_pull_request(
|
|
|
mergeable=pr_merge_enabled, enable_notifications=False
|
|
|
)
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
params={"range-diff": range_diff},
|
|
|
)
|
|
|
)
|
|
|
|
|
|
for commit_id in pull_request.revisions:
|
|
|
response.mustcontain(commit_id)
|
|
|
|
|
|
response.mustcontain(pull_request.target_ref_parts.type)
|
|
|
response.mustcontain(pull_request.target_ref_parts.name)
|
|
|
|
|
|
response.mustcontain('class="pull-request-merge"')
|
|
|
|
|
|
if pr_merge_enabled:
|
|
|
response.mustcontain("Pull request reviewer approval is pending")
|
|
|
else:
|
|
|
response.mustcontain("Server-side pull request merging is disabled.")
|
|
|
|
|
|
if range_diff == "1":
|
|
|
response.mustcontain("Turn off: Show the diff as commit range")
|
|
|
|
|
|
def test_show_versions_of_pr(self, backend, csrf_token):
|
|
|
commits = [
|
|
|
{
|
|
|
"message": "initial-commit",
|
|
|
"added": [FileNode(b"test-file.txt", b"LINE1\n")],
|
|
|
},
|
|
|
{
|
|
|
"message": "commit-1",
|
|
|
"changed": [FileNode(b"test-file.txt", b"LINE1\nLINE2\n")],
|
|
|
},
|
|
|
# Above is the initial version of PR that changes a single line
|
|
|
# from now on we'll add 3x commit adding a nother line on each step
|
|
|
{
|
|
|
"message": "commit-2",
|
|
|
"changed": [FileNode(b"test-file.txt", b"LINE1\nLINE2\nLINE3\n")],
|
|
|
},
|
|
|
{
|
|
|
"message": "commit-3",
|
|
|
"changed": [
|
|
|
FileNode(b"test-file.txt", b"LINE1\nLINE2\nLINE3\nLINE4\n")
|
|
|
],
|
|
|
},
|
|
|
{
|
|
|
"message": "commit-4",
|
|
|
"changed": [
|
|
|
FileNode(b"test-file.txt", b"LINE1\nLINE2\nLINE3\nLINE4\nLINE5\n")
|
|
|
],
|
|
|
},
|
|
|
]
|
|
|
|
|
|
commit_ids = backend.create_master_repo(commits)
|
|
|
target = backend.create_repo(heads=["initial-commit"])
|
|
|
source = backend.create_repo(heads=["commit-1"])
|
|
|
source_repo_name = source.repo_name
|
|
|
target_repo_name = target.repo_name
|
|
|
|
|
|
target_ref = "branch:{branch}:{commit_id}".format(
|
|
|
branch=backend.default_branch_name, commit_id=commit_ids["initial-commit"]
|
|
|
)
|
|
|
source_ref = "branch:{branch}:{commit_id}".format(
|
|
|
branch=backend.default_branch_name, commit_id=commit_ids["commit-1"]
|
|
|
)
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path("pullrequest_create", repo_name=source.repo_name),
|
|
|
[
|
|
|
("source_repo", source_repo_name),
|
|
|
("source_ref", source_ref),
|
|
|
("target_repo", target_repo_name),
|
|
|
("target_ref", target_ref),
|
|
|
("common_ancestor", commit_ids["initial-commit"]),
|
|
|
("pullrequest_title", "Title"),
|
|
|
("pullrequest_desc", "Description"),
|
|
|
("description_renderer", "markdown"),
|
|
|
("__start__", "review_members:sequence"),
|
|
|
("__start__", "reviewer:mapping"),
|
|
|
("user_id", "1"),
|
|
|
("__start__", "reasons:sequence"),
|
|
|
("reason", "Some reason"),
|
|
|
("__end__", "reasons:sequence"),
|
|
|
("__start__", "rules:sequence"),
|
|
|
("__end__", "rules:sequence"),
|
|
|
("mandatory", "False"),
|
|
|
("__end__", "reviewer:mapping"),
|
|
|
("__end__", "review_members:sequence"),
|
|
|
("__start__", "revisions:sequence"),
|
|
|
("revisions", commit_ids["commit-1"]),
|
|
|
("__end__", "revisions:sequence"),
|
|
|
("user", ""),
|
|
|
("csrf_token", csrf_token),
|
|
|
],
|
|
|
status=302,
|
|
|
)
|
|
|
|
|
|
location = response.headers["Location"]
|
|
|
|
|
|
pull_request_id = location.rsplit("/", 1)[1]
|
|
|
assert pull_request_id != "new"
|
|
|
pull_request = PullRequest.get(int(pull_request_id))
|
|
|
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
|
|
|
# Show initial version of PR
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
response.mustcontain("commit-1")
|
|
|
response.mustcontain(no=["commit-2"])
|
|
|
response.mustcontain(no=["commit-3"])
|
|
|
response.mustcontain(no=["commit-4"])
|
|
|
|
|
|
response.mustcontain('cb-addition"></span><span>LINE2</span>')
|
|
|
response.mustcontain(no=["LINE3"])
|
|
|
response.mustcontain(no=["LINE4"])
|
|
|
response.mustcontain(no=["LINE5"])
|
|
|
|
|
|
# update PR #1
|
|
|
source_repo = Repository.get_by_repo_name(source_repo_name)
|
|
|
backend.pull_heads(source_repo, heads=["commit-2"])
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_update",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={"update_commits": "true", "csrf_token": csrf_token},
|
|
|
)
|
|
|
|
|
|
# update PR #2
|
|
|
source_repo = Repository.get_by_repo_name(source_repo_name)
|
|
|
backend.pull_heads(source_repo, heads=["commit-3"])
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_update",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={"update_commits": "true", "csrf_token": csrf_token},
|
|
|
)
|
|
|
|
|
|
# update PR #3
|
|
|
source_repo = Repository.get_by_repo_name(source_repo_name)
|
|
|
backend.pull_heads(source_repo, heads=["commit-4"])
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_update",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={"update_commits": "true", "csrf_token": csrf_token},
|
|
|
)
|
|
|
|
|
|
# Show final version !
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
# 3 updates, and the latest == 4
|
|
|
response.mustcontain("4 versions available for this pull request")
|
|
|
response.mustcontain(no=["rhodecode diff rendering error"])
|
|
|
|
|
|
# initial show must have 3 commits, and 3 adds
|
|
|
response.mustcontain("commit-1")
|
|
|
response.mustcontain("commit-2")
|
|
|
response.mustcontain("commit-3")
|
|
|
response.mustcontain("commit-4")
|
|
|
|
|
|
response.mustcontain('cb-addition"></span><span>LINE2</span>')
|
|
|
response.mustcontain('cb-addition"></span><span>LINE3</span>')
|
|
|
response.mustcontain('cb-addition"></span><span>LINE4</span>')
|
|
|
response.mustcontain('cb-addition"></span><span>LINE5</span>')
|
|
|
|
|
|
# fetch versions
|
|
|
pr = PullRequest.get(pull_request_id)
|
|
|
versions = [x.pull_request_version_id for x in pr.versions.all()]
|
|
|
assert len(versions) == 3
|
|
|
|
|
|
# show v1,v2,v3,v4
|
|
|
def cb_line(text):
|
|
|
return 'cb-addition"></span><span>{}</span>'.format(text)
|
|
|
|
|
|
def cb_context(text):
|
|
|
return (
|
|
|
'<span class="cb-code"><span class="cb-action cb-context">'
|
|
|
"</span><span>{}</span></span>".format(text)
|
|
|
)
|
|
|
|
|
|
commit_tests = {
|
|
|
# in response, not in response
|
|
|
1: (["commit-1"], ["commit-2", "commit-3", "commit-4"]),
|
|
|
2: (["commit-1", "commit-2"], ["commit-3", "commit-4"]),
|
|
|
3: (["commit-1", "commit-2", "commit-3"], ["commit-4"]),
|
|
|
4: (["commit-1", "commit-2", "commit-3", "commit-4"], []),
|
|
|
}
|
|
|
diff_tests = {
|
|
|
1: (["LINE2"], ["LINE3", "LINE4", "LINE5"]),
|
|
|
2: (["LINE2", "LINE3"], ["LINE4", "LINE5"]),
|
|
|
3: (["LINE2", "LINE3", "LINE4"], ["LINE5"]),
|
|
|
4: (["LINE2", "LINE3", "LINE4", "LINE5"], []),
|
|
|
}
|
|
|
for idx, ver in enumerate(versions, 1):
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
params={"version": ver},
|
|
|
)
|
|
|
)
|
|
|
|
|
|
response.mustcontain(no=["rhodecode diff rendering error"])
|
|
|
response.mustcontain("Showing changes at v{}".format(idx))
|
|
|
|
|
|
yes, no = commit_tests[idx]
|
|
|
for y in yes:
|
|
|
response.mustcontain(y)
|
|
|
for n in no:
|
|
|
response.mustcontain(no=n)
|
|
|
|
|
|
yes, no = diff_tests[idx]
|
|
|
for y in yes:
|
|
|
response.mustcontain(cb_line(y))
|
|
|
for n in no:
|
|
|
response.mustcontain(no=n)
|
|
|
|
|
|
# show diff between versions
|
|
|
diff_compare_tests = {
|
|
|
1: (["LINE3"], ["LINE1", "LINE2"]),
|
|
|
2: (["LINE3", "LINE4"], ["LINE1", "LINE2"]),
|
|
|
3: (["LINE3", "LINE4", "LINE5"], ["LINE1", "LINE2"]),
|
|
|
}
|
|
|
for idx, ver in enumerate(versions, 1):
|
|
|
adds, context = diff_compare_tests[idx]
|
|
|
|
|
|
to_ver = ver + 1
|
|
|
if idx == 3:
|
|
|
to_ver = "latest"
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
params={"from_version": versions[0], "version": to_ver},
|
|
|
)
|
|
|
)
|
|
|
|
|
|
response.mustcontain(no=["rhodecode diff rendering error"])
|
|
|
|
|
|
for a in adds:
|
|
|
response.mustcontain(cb_line(a))
|
|
|
for c in context:
|
|
|
response.mustcontain(cb_context(c))
|
|
|
|
|
|
# test version v2 -> v3
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
params={"from_version": versions[1], "version": versions[2]},
|
|
|
)
|
|
|
)
|
|
|
|
|
|
response.mustcontain(cb_context("LINE1"))
|
|
|
response.mustcontain(cb_context("LINE2"))
|
|
|
response.mustcontain(cb_context("LINE3"))
|
|
|
response.mustcontain(cb_line("LINE4"))
|
|
|
|
|
|
def test_close_status_visibility(self, pr_util, user_util, csrf_token):
|
|
|
# Logout
|
|
|
response = self.app.post(
|
|
|
h.route_path("logout"), params={"csrf_token": csrf_token}
|
|
|
)
|
|
|
# Login as regular user
|
|
|
response = self.app.post(
|
|
|
h.route_path("login"),
|
|
|
{"username": TEST_USER_REGULAR_LOGIN, "password": "test12"},
|
|
|
)
|
|
|
|
|
|
pull_request = pr_util.create_pull_request(author=TEST_USER_REGULAR_LOGIN)
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
response.mustcontain("Server-side pull request merging is disabled.")
|
|
|
|
|
|
assert_response = response.assert_response()
|
|
|
# for regular user without a merge permissions, we don't see it
|
|
|
assert_response.no_element_exists("#close-pull-request-action")
|
|
|
|
|
|
user_util.grant_user_permission_to_repo(
|
|
|
pull_request.target_repo,
|
|
|
UserModel().get_by_username(TEST_USER_REGULAR_LOGIN),
|
|
|
"repository.write",
|
|
|
)
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
response.mustcontain("Server-side pull request merging is disabled.")
|
|
|
|
|
|
assert_response = response.assert_response()
|
|
|
# now regular user has a merge permissions, we have CLOSE button
|
|
|
assert_response.one_element_exists("#close-pull-request-action")
|
|
|
|
|
|
def test_show_invalid_commit_id(self, pr_util):
|
|
|
# Simulating invalid revisions which will cause a lookup error
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
pull_request.revisions = ["invalid"]
|
|
|
Session().add(pull_request)
|
|
|
Session().commit()
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
for commit_id in pull_request.revisions:
|
|
|
response.mustcontain(commit_id)
|
|
|
|
|
|
def test_show_invalid_source_reference(self, pr_util):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
pull_request.source_ref = "branch:b:invalid"
|
|
|
Session().add(pull_request)
|
|
|
Session().commit()
|
|
|
|
|
|
self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
def test_edit_title_description(self, pr_util, csrf_token):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_update",
|
|
|
repo_name=pull_request.target_repo.repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={
|
|
|
"edit_pull_request": "true",
|
|
|
"title": "New title",
|
|
|
"description": "New description",
|
|
|
"csrf_token": csrf_token,
|
|
|
},
|
|
|
)
|
|
|
|
|
|
assert_session_flash(
|
|
|
response, "Pull request title & description updated.", category="success"
|
|
|
)
|
|
|
|
|
|
pull_request = PullRequest.get(pull_request_id)
|
|
|
assert pull_request.title == "New title"
|
|
|
assert pull_request.description == "New description"
|
|
|
|
|
|
def test_edit_title_description_special(self, pr_util, csrf_token):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_update",
|
|
|
repo_name=pull_request.target_repo.repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={
|
|
|
"edit_pull_request": "true",
|
|
|
"title": "New title {} {2} {foo}",
|
|
|
"description": "New description",
|
|
|
"csrf_token": csrf_token,
|
|
|
},
|
|
|
)
|
|
|
|
|
|
assert_session_flash(
|
|
|
response, "Pull request title & description updated.", category="success"
|
|
|
)
|
|
|
|
|
|
pull_request = PullRequest.get(pull_request_id)
|
|
|
assert pull_request.title_safe == "New title {{}} {{2}} {{foo}}"
|
|
|
|
|
|
def test_edit_title_description_closed(self, pr_util, csrf_token):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
repo_name = pull_request.target_repo.repo_name
|
|
|
pr_util.close()
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_update",
|
|
|
repo_name=repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={
|
|
|
"edit_pull_request": "true",
|
|
|
"title": "New title",
|
|
|
"description": "New description",
|
|
|
"csrf_token": csrf_token,
|
|
|
},
|
|
|
status=200,
|
|
|
)
|
|
|
assert_session_flash(
|
|
|
response, "Cannot update closed pull requests.", category="error"
|
|
|
)
|
|
|
|
|
|
def test_update_invalid_source_reference(self, pr_util, csrf_token):
|
|
|
from rhodecode.lib.vcs.backends.base import UpdateFailureReason
|
|
|
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
pull_request.source_ref = "branch:invalid-branch:invalid-commit-id"
|
|
|
Session().add(pull_request)
|
|
|
Session().commit()
|
|
|
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_update",
|
|
|
repo_name=pull_request.target_repo.repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={"update_commits": "true", "csrf_token": csrf_token},
|
|
|
)
|
|
|
|
|
|
expected_msg = str(
|
|
|
PullRequestModel.UPDATE_STATUS_MESSAGES[
|
|
|
UpdateFailureReason.MISSING_SOURCE_REF
|
|
|
]
|
|
|
)
|
|
|
assert_session_flash(response, expected_msg, category="error")
|
|
|
|
|
|
def test_missing_target_reference(self, pr_util, csrf_token):
|
|
|
from rhodecode.lib.vcs.backends.base import MergeFailureReason
|
|
|
|
|
|
pull_request = pr_util.create_pull_request(approved=True, mergeable=True)
|
|
|
unicode_reference = "branch:invalid-branch:invalid-commit-id"
|
|
|
pull_request.target_ref = unicode_reference
|
|
|
Session().add(pull_request)
|
|
|
Session().commit()
|
|
|
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
pull_request_url = route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
)
|
|
|
|
|
|
response = self.app.get(pull_request_url)
|
|
|
# target_ref_id = "invalid-branch"
|
|
|
|
|
|
merge_resp = MergeResponse(
|
|
|
True,
|
|
|
True,
|
|
|
Reference("commit", "STUB_COMMIT_ID", "STUB_COMMIT_ID"),
|
|
|
MergeFailureReason.MISSING_TARGET_REF,
|
|
|
metadata={
|
|
|
"target_ref": PullRequest.unicode_to_reference(unicode_reference)
|
|
|
},
|
|
|
)
|
|
|
response.assert_response().element_contains(
|
|
|
'div[data-role="merge-message"]', merge_resp.merge_status_message
|
|
|
)
|
|
|
|
|
|
def test_comment_and_close_pull_request_custom_message_approved(
|
|
|
self, pr_util, csrf_token, xhr_header
|
|
|
):
|
|
|
pull_request = pr_util.create_pull_request(approved=True)
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
author = pull_request.user_id
|
|
|
repo = pull_request.target_repo.repo_id
|
|
|
|
|
|
self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_create",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={
|
|
|
"close_pull_request": "1",
|
|
|
"text": "Closing a PR",
|
|
|
"csrf_token": csrf_token,
|
|
|
},
|
|
|
extra_environ=xhr_header,
|
|
|
)
|
|
|
|
|
|
journal = (
|
|
|
UserLog.query()
|
|
|
.filter(UserLog.user_id == author)
|
|
|
.filter(UserLog.repository_id == repo)
|
|
|
.order_by(UserLog.user_log_id.asc())
|
|
|
.all()
|
|
|
)
|
|
|
assert journal[-1].action == "repo.pull_request.close"
|
|
|
|
|
|
pull_request = PullRequest.get(pull_request_id)
|
|
|
assert pull_request.is_closed()
|
|
|
|
|
|
status = ChangesetStatusModel().get_status(
|
|
|
pull_request.source_repo, pull_request=pull_request
|
|
|
)
|
|
|
assert status == ChangesetStatus.STATUS_APPROVED
|
|
|
comments = (
|
|
|
ChangesetComment()
|
|
|
.query()
|
|
|
.filter(ChangesetComment.pull_request == pull_request)
|
|
|
.order_by(ChangesetComment.comment_id.asc())
|
|
|
.all()
|
|
|
)
|
|
|
assert comments[-1].text == "Closing a PR"
|
|
|
|
|
|
def test_comment_force_close_pull_request_rejected(
|
|
|
self, pr_util, csrf_token, xhr_header
|
|
|
):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
PullRequestModel().update_reviewers(
|
|
|
pull_request_id,
|
|
|
[
|
|
|
(1, ["reason"], False, "reviewer", []),
|
|
|
(2, ["reason2"], False, "reviewer", []),
|
|
|
],
|
|
|
pull_request.author,
|
|
|
)
|
|
|
author = pull_request.user_id
|
|
|
repo = pull_request.target_repo.repo_id
|
|
|
|
|
|
self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_create",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={"close_pull_request": "1", "csrf_token": csrf_token},
|
|
|
extra_environ=xhr_header,
|
|
|
)
|
|
|
|
|
|
pull_request = PullRequest.get(pull_request_id)
|
|
|
|
|
|
journal = (
|
|
|
UserLog.query()
|
|
|
.filter(UserLog.user_id == author, UserLog.repository_id == repo)
|
|
|
.order_by(UserLog.user_log_id.asc())
|
|
|
.all()
|
|
|
)
|
|
|
assert journal[-1].action == "repo.pull_request.close"
|
|
|
|
|
|
# check only the latest status, not the review status
|
|
|
status = ChangesetStatusModel().get_status(
|
|
|
pull_request.source_repo, pull_request=pull_request
|
|
|
)
|
|
|
assert status == ChangesetStatus.STATUS_REJECTED
|
|
|
|
|
|
def test_comment_and_close_pull_request(self, pr_util, csrf_token, xhr_header):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_create",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
),
|
|
|
params={"close_pull_request": "true", "csrf_token": csrf_token},
|
|
|
extra_environ=xhr_header,
|
|
|
)
|
|
|
|
|
|
assert response.json
|
|
|
|
|
|
pull_request = PullRequest.get(pull_request_id)
|
|
|
assert pull_request.is_closed()
|
|
|
|
|
|
# check only the latest status, not the review status
|
|
|
status = ChangesetStatusModel().get_status(
|
|
|
pull_request.source_repo, pull_request=pull_request
|
|
|
)
|
|
|
assert status == ChangesetStatus.STATUS_REJECTED
|
|
|
|
|
|
def test_comment_and_close_pull_request_try_edit_comment(
|
|
|
self, pr_util, csrf_token, xhr_header
|
|
|
):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
target_scm = pull_request.target_repo.scm_instance()
|
|
|
target_scm_name = target_scm.name
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_create",
|
|
|
repo_name=target_scm_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={
|
|
|
"close_pull_request": "true",
|
|
|
"csrf_token": csrf_token,
|
|
|
},
|
|
|
extra_environ=xhr_header,
|
|
|
)
|
|
|
|
|
|
assert response.json
|
|
|
|
|
|
pull_request = PullRequest.get(pull_request_id)
|
|
|
target_scm = pull_request.target_repo.scm_instance()
|
|
|
target_scm_name = target_scm.name
|
|
|
assert pull_request.is_closed()
|
|
|
|
|
|
# check only the latest status, not the review status
|
|
|
status = ChangesetStatusModel().get_status(
|
|
|
pull_request.source_repo, pull_request=pull_request
|
|
|
)
|
|
|
assert status == ChangesetStatus.STATUS_REJECTED
|
|
|
|
|
|
for comment_id in response.json.keys():
|
|
|
test_text = "test"
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_edit",
|
|
|
repo_name=target_scm_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
comment_id=comment_id,
|
|
|
),
|
|
|
extra_environ=xhr_header,
|
|
|
params={
|
|
|
"csrf_token": csrf_token,
|
|
|
"text": test_text,
|
|
|
},
|
|
|
status=403,
|
|
|
)
|
|
|
assert response.status_int == 403
|
|
|
|
|
|
def test_comment_and_comment_edit(self, pr_util, csrf_token, xhr_header):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
target_scm = pull_request.target_repo.scm_instance()
|
|
|
target_scm_name = target_scm.name
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_create",
|
|
|
repo_name=target_scm_name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
),
|
|
|
params={
|
|
|
"csrf_token": csrf_token,
|
|
|
"text": "init",
|
|
|
},
|
|
|
extra_environ=xhr_header,
|
|
|
)
|
|
|
assert response.json
|
|
|
|
|
|
for comment_id in response.json.keys():
|
|
|
assert comment_id
|
|
|
test_text = "test"
|
|
|
self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_edit",
|
|
|
repo_name=target_scm_name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
comment_id=comment_id,
|
|
|
),
|
|
|
extra_environ=xhr_header,
|
|
|
params={
|
|
|
"csrf_token": csrf_token,
|
|
|
"text": test_text,
|
|
|
"version": "0",
|
|
|
},
|
|
|
)
|
|
|
text_form_db = (
|
|
|
ChangesetComment.query()
|
|
|
.filter(ChangesetComment.comment_id == comment_id)
|
|
|
.first()
|
|
|
.text
|
|
|
)
|
|
|
assert test_text == text_form_db
|
|
|
|
|
|
def test_comment_and_comment_edit_special(self, pr_util, csrf_token, xhr_header):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
target_scm = pull_request.target_repo.scm_instance()
|
|
|
target_scm_name = target_scm.name
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_create",
|
|
|
repo_name=target_scm_name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
),
|
|
|
params={
|
|
|
"csrf_token": csrf_token,
|
|
|
"text": "init",
|
|
|
},
|
|
|
extra_environ=xhr_header,
|
|
|
)
|
|
|
assert response.json
|
|
|
|
|
|
for comment_id in response.json.keys():
|
|
|
test_text = "init"
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_edit",
|
|
|
repo_name=target_scm_name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
comment_id=comment_id,
|
|
|
),
|
|
|
extra_environ=xhr_header,
|
|
|
params={
|
|
|
"csrf_token": csrf_token,
|
|
|
"text": test_text,
|
|
|
"version": "0",
|
|
|
},
|
|
|
status=404,
|
|
|
)
|
|
|
assert response.status_int == 404
|
|
|
|
|
|
def test_comment_and_try_edit_already_edited(self, pr_util, csrf_token, xhr_header):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
target_scm = pull_request.target_repo.scm_instance()
|
|
|
target_scm_name = target_scm.name
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_create",
|
|
|
repo_name=target_scm_name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
),
|
|
|
params={
|
|
|
"csrf_token": csrf_token,
|
|
|
"text": "init",
|
|
|
},
|
|
|
extra_environ=xhr_header,
|
|
|
)
|
|
|
assert response.json
|
|
|
for comment_id in response.json.keys():
|
|
|
test_text = "test"
|
|
|
self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_edit",
|
|
|
repo_name=target_scm_name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
comment_id=comment_id,
|
|
|
),
|
|
|
extra_environ=xhr_header,
|
|
|
params={
|
|
|
"csrf_token": csrf_token,
|
|
|
"text": test_text,
|
|
|
"version": "0",
|
|
|
},
|
|
|
)
|
|
|
test_text_v2 = "test_v2"
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_edit",
|
|
|
repo_name=target_scm_name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
comment_id=comment_id,
|
|
|
),
|
|
|
extra_environ=xhr_header,
|
|
|
params={
|
|
|
"csrf_token": csrf_token,
|
|
|
"text": test_text_v2,
|
|
|
"version": "0",
|
|
|
},
|
|
|
status=409,
|
|
|
)
|
|
|
assert response.status_int == 409
|
|
|
|
|
|
text_form_db = (
|
|
|
ChangesetComment.query()
|
|
|
.filter(ChangesetComment.comment_id == comment_id)
|
|
|
.first()
|
|
|
.text
|
|
|
)
|
|
|
|
|
|
assert test_text == text_form_db
|
|
|
assert test_text_v2 != text_form_db
|
|
|
|
|
|
def test_comment_and_comment_edit_permissions_forbidden(
|
|
|
self,
|
|
|
autologin_regular_user,
|
|
|
user_regular,
|
|
|
user_admin,
|
|
|
pr_util,
|
|
|
csrf_token,
|
|
|
xhr_header,
|
|
|
):
|
|
|
pull_request = pr_util.create_pull_request(
|
|
|
author=user_admin.username, enable_notifications=False
|
|
|
)
|
|
|
comment = CommentsModel().create(
|
|
|
text="test",
|
|
|
repo=pull_request.target_repo.scm_instance().name,
|
|
|
user=user_admin,
|
|
|
pull_request=pull_request,
|
|
|
)
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_edit",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
comment_id=comment.comment_id,
|
|
|
),
|
|
|
extra_environ=xhr_header,
|
|
|
params={
|
|
|
"csrf_token": csrf_token,
|
|
|
"text": "test_text",
|
|
|
},
|
|
|
status=403,
|
|
|
)
|
|
|
assert response.status_int == 403
|
|
|
|
|
|
def test_create_pull_request(self, backend, csrf_token):
|
|
|
commits = [
|
|
|
{"message": "ancestor"},
|
|
|
{"message": "change"},
|
|
|
{"message": "change2"},
|
|
|
]
|
|
|
commit_ids = backend.create_master_repo(commits)
|
|
|
target = backend.create_repo(heads=["ancestor"])
|
|
|
source = backend.create_repo(heads=["change2"])
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path("pullrequest_create", repo_name=source.repo_name),
|
|
|
[
|
|
|
("source_repo", source.repo_name),
|
|
|
("source_ref", "branch:default:" + commit_ids["change2"]),
|
|
|
("target_repo", target.repo_name),
|
|
|
("target_ref", "branch:default:" + commit_ids["ancestor"]),
|
|
|
("common_ancestor", commit_ids["ancestor"]),
|
|
|
("pullrequest_title", "Title"),
|
|
|
("pullrequest_desc", "Description"),
|
|
|
("description_renderer", "markdown"),
|
|
|
("__start__", "review_members:sequence"),
|
|
|
("__start__", "reviewer:mapping"),
|
|
|
("user_id", "1"),
|
|
|
("__start__", "reasons:sequence"),
|
|
|
("reason", "Some reason"),
|
|
|
("__end__", "reasons:sequence"),
|
|
|
("__start__", "rules:sequence"),
|
|
|
("__end__", "rules:sequence"),
|
|
|
("mandatory", "False"),
|
|
|
("__end__", "reviewer:mapping"),
|
|
|
("__end__", "review_members:sequence"),
|
|
|
("__start__", "revisions:sequence"),
|
|
|
("revisions", commit_ids["change"]),
|
|
|
("revisions", commit_ids["change2"]),
|
|
|
("__end__", "revisions:sequence"),
|
|
|
("user", ""),
|
|
|
("csrf_token", csrf_token),
|
|
|
],
|
|
|
status=302,
|
|
|
)
|
|
|
|
|
|
location = response.headers["Location"]
|
|
|
pull_request_id = location.rsplit("/", 1)[1]
|
|
|
assert pull_request_id != "new"
|
|
|
pull_request = PullRequest.get(int(pull_request_id))
|
|
|
|
|
|
# check that we have now both revisions
|
|
|
assert pull_request.revisions == [commit_ids["change2"], commit_ids["change"]]
|
|
|
assert pull_request.source_ref == "branch:default:" + commit_ids["change2"]
|
|
|
expected_target_ref = "branch:default:" + commit_ids["ancestor"]
|
|
|
assert pull_request.target_ref == expected_target_ref
|
|
|
|
|
|
def test_reviewer_notifications(self, backend, csrf_token):
|
|
|
# We have to use the app.post for this test, so it will create the
|
|
|
# notifications properly with the new PR
|
|
|
commits = [
|
|
|
{
|
|
|
"message": "ancestor",
|
|
|
"added": [FileNode(b"file_A", content=b"content_of_ancestor")],
|
|
|
},
|
|
|
{
|
|
|
"message": "change",
|
|
|
"added": [FileNode(b"file_a", content=b"content_of_change")],
|
|
|
},
|
|
|
{"message": "change-child"},
|
|
|
{
|
|
|
"message": "ancestor-child",
|
|
|
"parents": ["ancestor"],
|
|
|
"branch": "feature",
|
|
|
"added": [FileNode(b"file_c", content=b"content_of_ancestor_child")],
|
|
|
},
|
|
|
{"message": "ancestor-child-2", "branch": "feature"},
|
|
|
]
|
|
|
commit_ids = backend.create_master_repo(commits)
|
|
|
target = backend.create_repo(heads=["ancestor-child"])
|
|
|
source = backend.create_repo(heads=["change"])
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path("pullrequest_create", repo_name=source.repo_name),
|
|
|
[
|
|
|
("source_repo", source.repo_name),
|
|
|
("source_ref", "branch:default:" + commit_ids["change"]),
|
|
|
("target_repo", target.repo_name),
|
|
|
("target_ref", "branch:default:" + commit_ids["ancestor-child"]),
|
|
|
("common_ancestor", commit_ids["ancestor"]),
|
|
|
("pullrequest_title", "Title"),
|
|
|
("pullrequest_desc", "Description"),
|
|
|
("description_renderer", "markdown"),
|
|
|
("__start__", "review_members:sequence"),
|
|
|
("__start__", "reviewer:mapping"),
|
|
|
("user_id", "2"),
|
|
|
("__start__", "reasons:sequence"),
|
|
|
("reason", "Some reason"),
|
|
|
("__end__", "reasons:sequence"),
|
|
|
("__start__", "rules:sequence"),
|
|
|
("__end__", "rules:sequence"),
|
|
|
("mandatory", "False"),
|
|
|
("__end__", "reviewer:mapping"),
|
|
|
("__end__", "review_members:sequence"),
|
|
|
("__start__", "revisions:sequence"),
|
|
|
("revisions", commit_ids["change"]),
|
|
|
("__end__", "revisions:sequence"),
|
|
|
("user", ""),
|
|
|
("csrf_token", csrf_token),
|
|
|
],
|
|
|
status=302,
|
|
|
)
|
|
|
|
|
|
location = response.headers["Location"]
|
|
|
|
|
|
pull_request_id = location.rsplit("/", 1)[1]
|
|
|
assert pull_request_id != "new"
|
|
|
pull_request = PullRequest.get(int(pull_request_id))
|
|
|
|
|
|
# Check that a notification was made
|
|
|
notifications = Notification.query().filter(
|
|
|
Notification.created_by == pull_request.author.user_id,
|
|
|
Notification.type_ == Notification.TYPE_PULL_REQUEST,
|
|
|
Notification.subject.contains(
|
|
|
"requested a pull request review. !%s" % pull_request_id
|
|
|
),
|
|
|
)
|
|
|
assert len(notifications.all()) == 1
|
|
|
|
|
|
# Change reviewers and check that a notification was made
|
|
|
PullRequestModel().update_reviewers(
|
|
|
pull_request.pull_request_id,
|
|
|
[(1, [], False, "reviewer", [])],
|
|
|
pull_request.author,
|
|
|
)
|
|
|
assert len(notifications.all()) == 2
|
|
|
|
|
|
@pytest.mark.xfail(reason="unable to fix this test after python3 migration")
|
|
|
def test_create_pull_request_stores_ancestor_commit_id(self, backend, csrf_token):
|
|
|
commits = [
|
|
|
{
|
|
|
"message": "ancestor",
|
|
|
"added": [FileNode(b"file_A", content=b"content_of_ancestor")],
|
|
|
},
|
|
|
{
|
|
|
"message": "change",
|
|
|
"added": [FileNode(b"file_a", content=b"content_of_change")],
|
|
|
},
|
|
|
{
|
|
|
"message": "change-child",
|
|
|
"added": [FileNode(b"file_c", content=b"content_of_change_2")],
|
|
|
},
|
|
|
{
|
|
|
"message": "ancestor-child",
|
|
|
"parents": ["ancestor"],
|
|
|
"branch": "feature",
|
|
|
"added": [FileNode(b"file_B", content=b"content_of_ancestor_child")],
|
|
|
},
|
|
|
{"message": "ancestor-child-2", "branch": "feature"},
|
|
|
]
|
|
|
commit_ids = backend.create_master_repo(commits)
|
|
|
target = backend.create_repo(heads=["ancestor-child"])
|
|
|
source = backend.create_repo(heads=["change"])
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path("pullrequest_create", repo_name=source.repo_name),
|
|
|
[
|
|
|
("source_repo", source.repo_name),
|
|
|
("source_ref", "branch:default:" + commit_ids["change"]),
|
|
|
("target_repo", target.repo_name),
|
|
|
("target_ref", "branch:default:" + commit_ids["ancestor-child"]),
|
|
|
("common_ancestor", commit_ids["ancestor"]),
|
|
|
("pullrequest_title", "Title"),
|
|
|
("pullrequest_desc", "Description"),
|
|
|
("description_renderer", "markdown"),
|
|
|
("__start__", "review_members:sequence"),
|
|
|
("__start__", "reviewer:mapping"),
|
|
|
("user_id", "1"),
|
|
|
("__start__", "reasons:sequence"),
|
|
|
("reason", "Some reason"),
|
|
|
("__end__", "reasons:sequence"),
|
|
|
("__start__", "rules:sequence"),
|
|
|
("__end__", "rules:sequence"),
|
|
|
("mandatory", "False"),
|
|
|
("__end__", "reviewer:mapping"),
|
|
|
("__end__", "review_members:sequence"),
|
|
|
("__start__", "revisions:sequence"),
|
|
|
("revisions", commit_ids["change"]),
|
|
|
("__end__", "revisions:sequence"),
|
|
|
("user", ""),
|
|
|
("csrf_token", csrf_token),
|
|
|
],
|
|
|
status=302,
|
|
|
)
|
|
|
|
|
|
location = response.headers["Location"]
|
|
|
|
|
|
pull_request_id = location.rsplit("/", 1)[1]
|
|
|
assert pull_request_id != "new"
|
|
|
pull_request = PullRequest.get(int(pull_request_id))
|
|
|
|
|
|
# target_ref has to point to the ancestor's commit_id in order to
|
|
|
# show the correct diff
|
|
|
expected_target_ref = "branch:default:" + commit_ids["ancestor"]
|
|
|
assert pull_request.target_ref == expected_target_ref
|
|
|
|
|
|
# Check generated diff contents
|
|
|
response = response.follow()
|
|
|
response.mustcontain(no=["content_of_ancestor"])
|
|
|
response.mustcontain(no=["content_of_ancestor-child"])
|
|
|
response.mustcontain("content_of_change")
|
|
|
|
|
|
def test_merge_pull_request_enabled(self, pr_util, csrf_token):
|
|
|
# Clear any previous calls to rcextensions
|
|
|
rhodecode.EXTENSIONS.calls.clear()
|
|
|
|
|
|
pull_request = pr_util.create_pull_request(approved=True, mergeable=True)
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
repo_name = (pull_request.target_repo.scm_instance().name,)
|
|
|
|
|
|
url = route_path(
|
|
|
"pullrequest_merge",
|
|
|
repo_name=str(repo_name[0]),
|
|
|
pull_request_id=pull_request_id,
|
|
|
)
|
|
|
response = self.app.post(url, params={"csrf_token": csrf_token}).follow()
|
|
|
|
|
|
pull_request = PullRequest.get(pull_request_id)
|
|
|
|
|
|
assert response.status_int == 200
|
|
|
assert pull_request.is_closed()
|
|
|
assert_pull_request_status(pull_request, ChangesetStatus.STATUS_APPROVED)
|
|
|
|
|
|
# Check the relevant log entries were added
|
|
|
user_logs = UserLog.query().order_by(UserLog.user_log_id.desc()).limit(3)
|
|
|
actions = [log.action for log in user_logs]
|
|
|
pr_commit_ids = PullRequestModel()._get_commit_ids(pull_request)
|
|
|
expected_actions = [
|
|
|
"repo.pull_request.close",
|
|
|
"repo.pull_request.merge",
|
|
|
"repo.pull_request.comment.create",
|
|
|
]
|
|
|
assert actions == expected_actions
|
|
|
|
|
|
user_logs = UserLog.query().order_by(UserLog.user_log_id.desc()).limit(4)
|
|
|
actions = [log for log in user_logs]
|
|
|
assert actions[-1].action == "user.push"
|
|
|
assert actions[-1].action_data["commit_ids"] == pr_commit_ids
|
|
|
|
|
|
# Check post_push rcextension was really executed
|
|
|
push_calls = rhodecode.EXTENSIONS.calls["_push_hook"]
|
|
|
assert len(push_calls) == 1
|
|
|
unused_last_call_args, last_call_kwargs = push_calls[0]
|
|
|
assert last_call_kwargs["action"] == "push"
|
|
|
assert last_call_kwargs["commit_ids"] == pr_commit_ids
|
|
|
|
|
|
def test_merge_pull_request_disabled(self, pr_util, csrf_token):
|
|
|
pull_request = pr_util.create_pull_request(mergeable=False)
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
pull_request = PullRequest.get(pull_request_id)
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_merge",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
),
|
|
|
params={"csrf_token": csrf_token},
|
|
|
).follow()
|
|
|
|
|
|
assert response.status_int == 200
|
|
|
response.mustcontain(
|
|
|
"Merge is not currently possible because of below failed checks."
|
|
|
)
|
|
|
response.mustcontain("Server-side pull request merging is disabled.")
|
|
|
|
|
|
@pytest.mark.skip_backends("svn")
|
|
|
def test_merge_pull_request_not_approved(self, pr_util, csrf_token):
|
|
|
pull_request = pr_util.create_pull_request(mergeable=True)
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
repo_name = pull_request.target_repo.scm_instance().name
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_merge",
|
|
|
repo_name=repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={"csrf_token": csrf_token},
|
|
|
).follow()
|
|
|
|
|
|
assert response.status_int == 200
|
|
|
|
|
|
response.mustcontain(
|
|
|
"Merge is not currently possible because of below failed checks."
|
|
|
)
|
|
|
response.mustcontain("Pull request reviewer approval is pending.")
|
|
|
|
|
|
def test_merge_pull_request_renders_failure_reason(
|
|
|
self, user_regular, csrf_token, pr_util
|
|
|
):
|
|
|
pull_request = pr_util.create_pull_request(mergeable=True, approved=True)
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
repo_name = pull_request.target_repo.scm_instance().name
|
|
|
|
|
|
merge_resp = MergeResponse(
|
|
|
True,
|
|
|
False,
|
|
|
Reference("commit", "STUB_COMMIT_ID", "STUB_COMMIT_ID"),
|
|
|
MergeFailureReason.PUSH_FAILED,
|
|
|
metadata={"target": "shadow repo", "merge_commit": "xxx"},
|
|
|
)
|
|
|
model_patcher = mock.patch.multiple(
|
|
|
PullRequestModel,
|
|
|
merge_repo=mock.Mock(return_value=merge_resp),
|
|
|
merge_status=mock.Mock(return_value=(None, True, "WRONG_MESSAGE")),
|
|
|
)
|
|
|
|
|
|
with model_patcher:
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_merge",
|
|
|
repo_name=repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={"csrf_token": csrf_token},
|
|
|
status=302,
|
|
|
)
|
|
|
|
|
|
merge_resp = MergeResponse(
|
|
|
True,
|
|
|
True,
|
|
|
Reference("commit", "STUB_COMMIT_ID", "STUB_COMMIT_ID"),
|
|
|
MergeFailureReason.PUSH_FAILED,
|
|
|
metadata={"target": "shadow repo", "merge_commit": "xxx"},
|
|
|
)
|
|
|
assert_session_flash(response, merge_resp.merge_status_message)
|
|
|
|
|
|
def test_update_source_revision(self, backend, csrf_token):
|
|
|
commits = [
|
|
|
{"message": "ancestor"},
|
|
|
{"message": "change"},
|
|
|
{"message": "change-2"},
|
|
|
]
|
|
|
commit_ids = backend.create_master_repo(commits)
|
|
|
target = backend.create_repo(heads=["ancestor"])
|
|
|
source = backend.create_repo(heads=["change"])
|
|
|
|
|
|
# create pr from a in source to A in target
|
|
|
pull_request = PullRequest()
|
|
|
|
|
|
pull_request.source_repo = source
|
|
|
pull_request.source_ref = "branch:{branch}:{commit_id}".format(
|
|
|
branch=backend.default_branch_name, commit_id=commit_ids["change"]
|
|
|
)
|
|
|
|
|
|
pull_request.target_repo = target
|
|
|
pull_request.target_ref = "branch:{branch}:{commit_id}".format(
|
|
|
branch=backend.default_branch_name, commit_id=commit_ids["ancestor"]
|
|
|
)
|
|
|
|
|
|
pull_request.revisions = [commit_ids["change"]]
|
|
|
pull_request.title = "Test"
|
|
|
pull_request.description = "Description"
|
|
|
pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
|
|
|
pull_request.pull_request_state = PullRequest.STATE_CREATED
|
|
|
Session().add(pull_request)
|
|
|
Session().commit()
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
|
|
|
# source has ancestor - change - change-2
|
|
|
backend.pull_heads(source, heads=["change-2"])
|
|
|
target_repo_name = target.repo_name
|
|
|
|
|
|
# update PR
|
|
|
self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_update",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={"update_commits": "true", "csrf_token": csrf_token},
|
|
|
)
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
assert response.status_int == 200
|
|
|
response.mustcontain("Pull request updated to")
|
|
|
response.mustcontain("with 1 added, 0 removed commits.")
|
|
|
|
|
|
# check that we have now both revisions
|
|
|
pull_request = PullRequest.get(pull_request_id)
|
|
|
assert pull_request.revisions == [commit_ids["change-2"], commit_ids["change"]]
|
|
|
|
|
|
def test_update_target_revision(self, backend, csrf_token):
|
|
|
"""
|
|
|
Checks when we add more commits into a target branch, and update PR
|
|
|
"""
|
|
|
|
|
|
commits = [
|
|
|
{"message": "commit-a"}, # main branch (our PR target)
|
|
|
{"message": "commit-b"}, # Initial source
|
|
|
{"message": "commit-c"},
|
|
|
|
|
|
{"message": "commit-a-prime", "branch": "feature", "parents": ["commit-a"]}, # main branch (source)
|
|
|
]
|
|
|
|
|
|
commit_ids = backend.create_master_repo(commits)
|
|
|
target = backend.create_repo(heads=["commit-a"])
|
|
|
source = backend.create_repo(heads=["commit-b"])
|
|
|
target_repo_name = target.repo_name
|
|
|
|
|
|
# create pr from commit-b to commit-a
|
|
|
pull_request = PullRequest()
|
|
|
|
|
|
pull_request.target_repo = target
|
|
|
pull_request.target_ref = "branch:{branch}:{commit_id}".format(
|
|
|
branch=backend.default_branch_name, commit_id=commit_ids["commit-a"]
|
|
|
)
|
|
|
|
|
|
pull_request.source_repo = source
|
|
|
pull_request.source_ref = "branch:{branch}:{commit_id}".format(
|
|
|
branch=backend.default_branch_name, commit_id=commit_ids["commit-b"]
|
|
|
)
|
|
|
|
|
|
pull_request.revisions = [commit_ids["commit-b"]]
|
|
|
pull_request.title = "Test"
|
|
|
pull_request.description = "Description"
|
|
|
pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
|
|
|
pull_request.pull_request_state = PullRequest.STATE_CREATED
|
|
|
|
|
|
Session().add(pull_request)
|
|
|
Session().commit()
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
|
|
|
# target - add one commit on top commit-a -> commit-b
|
|
|
backend.pull_heads(target, heads=["commit-b"])
|
|
|
|
|
|
# source has ancestor - ancestor-new - change-rebased
|
|
|
backend.pull_heads(source, heads=["commit-c"])
|
|
|
|
|
|
# update PR
|
|
|
url = route_path(
|
|
|
"pullrequest_update",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
)
|
|
|
self.app.post(
|
|
|
url, params={"update_commits": "true", "csrf_token": csrf_token}, status=200
|
|
|
)
|
|
|
|
|
|
# check that we have now both revisions
|
|
|
pull_request = PullRequest.get(pull_request_id)
|
|
|
assert pull_request.revisions == [commit_ids["commit-c"]]
|
|
|
assert pull_request.target_ref == "branch:{branch}:{commit_id}".format(
|
|
|
branch=backend.default_branch_name, commit_id=commit_ids["commit-b"]
|
|
|
)
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
assert response.status_int == 200
|
|
|
response.mustcontain("Pull request updated to")
|
|
|
response.mustcontain("with 1 added, 1 removed commits.")
|
|
|
|
|
|
def test_update_target_revision_with_removal_of_1_commit_git(
|
|
|
self, backend_git, csrf_token
|
|
|
):
|
|
|
backend = backend_git
|
|
|
commits = [
|
|
|
{"message": "master-commit-1"},
|
|
|
{"message": "master-commit-2-change-1"},
|
|
|
{"message": "master-commit-3-change-2"},
|
|
|
{
|
|
|
"message": "feat-commit-1",
|
|
|
"parents": ["master-commit-1"],
|
|
|
"branch": "feature",
|
|
|
},
|
|
|
{"message": "feat-commit-2", "branch": "feature"},
|
|
|
]
|
|
|
commit_ids = backend.create_master_repo(commits)
|
|
|
target = backend.create_repo(heads=["master-commit-3-change-2"])
|
|
|
source = backend.create_repo(heads=["feat-commit-2"])
|
|
|
|
|
|
# create pr from a in source to A in target
|
|
|
pull_request = PullRequest()
|
|
|
pull_request.source_repo = source
|
|
|
|
|
|
pull_request.source_ref = "branch:{branch}:{commit_id}".format(
|
|
|
branch=backend.default_branch_name,
|
|
|
commit_id=commit_ids["master-commit-3-change-2"],
|
|
|
)
|
|
|
|
|
|
pull_request.target_repo = target
|
|
|
pull_request.target_ref = "branch:{branch}:{commit_id}".format(
|
|
|
branch=backend.default_branch_name, commit_id=commit_ids["feat-commit-2"]
|
|
|
)
|
|
|
|
|
|
pull_request.revisions = [
|
|
|
commit_ids["feat-commit-1"],
|
|
|
commit_ids["feat-commit-2"],
|
|
|
]
|
|
|
pull_request.title = "Test"
|
|
|
pull_request.description = "Description"
|
|
|
pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
|
|
|
pull_request.pull_request_state = PullRequest.STATE_CREATED
|
|
|
Session().add(pull_request)
|
|
|
Session().commit()
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
|
|
|
# PR is created, now we simulate a force-push into target,
|
|
|
# that drops a 2 last commits
|
|
|
vcsrepo = target.scm_instance()
|
|
|
vcsrepo.config.clear_section("hooks")
|
|
|
vcsrepo.run_git_command(["reset", "--soft", "HEAD~2"])
|
|
|
target_repo_name = target.repo_name
|
|
|
|
|
|
# update PR
|
|
|
url = route_path(
|
|
|
"pullrequest_update",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
)
|
|
|
self.app.post(
|
|
|
url, params={"update_commits": "true", "csrf_token": csrf_token}, status=200
|
|
|
)
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path("pullrequest_new", repo_name=target_repo_name)
|
|
|
)
|
|
|
assert response.status_int == 200
|
|
|
response.mustcontain("Pull request updated to")
|
|
|
response.mustcontain("with 0 added, 0 removed commits.")
|
|
|
|
|
|
@pytest.mark.xfail(reason="unable to fix after pygit update")
|
|
|
def test_update_pr_ancestor_reference(self, csrf_token, pr_util: PRTestUtility):
|
|
|
commits = [
|
|
|
{"message": "ancestor"},
|
|
|
{"message": "change"},
|
|
|
{"message": "change-2"},
|
|
|
|
|
|
{"message": "ancestor-new", "parents": ["ancestor"], "branch": "feature"},
|
|
|
{"message": "change-rebased", "branch": "feature"},
|
|
|
]
|
|
|
|
|
|
pull_request = pr_util.create_pull_request(
|
|
|
commits,
|
|
|
target_head="ancestor",
|
|
|
source_head="change",
|
|
|
revisions=["change"],
|
|
|
)
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
target_repo_name = pr_util.target_repository.repo_name
|
|
|
commit_ids = pr_util.commit_ids
|
|
|
|
|
|
assert pull_request.revisions == [commit_ids["change"]]
|
|
|
assert list(pull_request.target_repo.scm_instance(cache=False).branches.keys()) == [pr_util.backend.default_branch_name]
|
|
|
assert list(pull_request.source_repo.scm_instance(cache=False).branches.keys()) == [pr_util.backend.default_branch_name]
|
|
|
|
|
|
branch = "feature"
|
|
|
pr_util.update_target_repository(head="ancestor-new", do_fetch=True)
|
|
|
pr_util.set_pr_target_ref(ref_type="branch", ref_name=branch, ref_commit_id=commit_ids["ancestor-new"])
|
|
|
|
|
|
pr_util.update_source_repository(head="change-rebased", do_fetch=True)
|
|
|
pr_util.set_pr_source_ref(ref_type="branch", ref_name=branch, ref_commit_id=commit_ids["change-rebased"])
|
|
|
|
|
|
assert list(pull_request.target_repo.scm_instance(cache=False).branches.keys()) == [pr_util.backend.default_branch_name, branch]
|
|
|
assert list(pull_request.source_repo.scm_instance(cache=False).branches.keys()) == [pr_util.backend.default_branch_name, branch]
|
|
|
|
|
|
Session().add(pr_util.pull_request)
|
|
|
Session().commit()
|
|
|
|
|
|
self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_update",
|
|
|
repo_name=target_repo_name,
|
|
|
pull_request_id=pull_request_id,
|
|
|
),
|
|
|
params={"update_commits": "true", "csrf_token": csrf_token, "force_refresh": True},
|
|
|
status=200,
|
|
|
)
|
|
|
|
|
|
|
|
|
# response = self.app.get(
|
|
|
# route_path(
|
|
|
# "pullrequest_show", repo_name=target_repo_name, pull_request_id=pull_request_id,
|
|
|
# params={"force_refresh": True}
|
|
|
# ),
|
|
|
# )
|
|
|
#
|
|
|
# response.mustcontain("Pull request updated to")
|
|
|
# response.mustcontain("with 1 added, 0 removed commits.")
|
|
|
|
|
|
pull_request = PullRequest.get(pull_request_id)
|
|
|
|
|
|
assert pull_request.target_ref == "branch:{branch}:{commit_id}".format(
|
|
|
branch="feature", commit_id=commit_ids["ancestor-new"])
|
|
|
|
|
|
assert pull_request.revisions == [commit_ids["change-rebased"]]
|
|
|
|
|
|
|
|
|
def test_remove_pull_request_branch(self, backend_git, csrf_token):
|
|
|
branch_name = "development"
|
|
|
commits = [
|
|
|
{"message": "initial-commit"},
|
|
|
{"message": "old-feature"},
|
|
|
{"message": "new-feature", "branch": branch_name},
|
|
|
]
|
|
|
repo = backend_git.create_repo(commits)
|
|
|
repo_name = repo.repo_name
|
|
|
commit_ids = backend_git.commit_ids
|
|
|
|
|
|
pull_request = PullRequest()
|
|
|
pull_request.source_repo = repo
|
|
|
pull_request.target_repo = repo
|
|
|
pull_request.source_ref = "branch:{branch}:{commit_id}".format(
|
|
|
branch=branch_name, commit_id=commit_ids["new-feature"]
|
|
|
)
|
|
|
pull_request.target_ref = "branch:{branch}:{commit_id}".format(
|
|
|
branch=backend_git.default_branch_name, commit_id=commit_ids["old-feature"]
|
|
|
)
|
|
|
pull_request.revisions = [commit_ids["new-feature"]]
|
|
|
pull_request.title = "Test"
|
|
|
pull_request.description = "Description"
|
|
|
pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
|
|
|
pull_request.pull_request_state = PullRequest.STATE_CREATED
|
|
|
Session().add(pull_request)
|
|
|
Session().commit()
|
|
|
|
|
|
pull_request_id = pull_request.pull_request_id
|
|
|
|
|
|
vcs = repo.scm_instance()
|
|
|
vcs.remove_ref("refs/heads/{}".format(branch_name))
|
|
|
# NOTE(marcink): run GC to ensure the commits are gone
|
|
|
vcs.run_gc()
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show", repo_name=repo_name, pull_request_id=pull_request_id
|
|
|
)
|
|
|
)
|
|
|
|
|
|
assert response.status_int == 200
|
|
|
|
|
|
response.assert_response().element_contains(
|
|
|
"#changeset_compare_view_content .alert strong", "Missing commits"
|
|
|
)
|
|
|
response.assert_response().element_contains(
|
|
|
"#changeset_compare_view_content .alert",
|
|
|
"This pull request cannot be displayed, because one or more"
|
|
|
" commits no longer exist in the source repository.",
|
|
|
)
|
|
|
|
|
|
def test_strip_commits_from_pull_request(self, backend, pr_util):
|
|
|
commits = [
|
|
|
{"message": "initial-commit"},
|
|
|
{"message": "old-feature"},
|
|
|
{"message": "new-feature"},
|
|
|
]
|
|
|
pull_request = pr_util.create_pull_request(
|
|
|
commits,
|
|
|
target_head="initial-commit",
|
|
|
source_head="new-feature",
|
|
|
revisions=["new-feature"],
|
|
|
)
|
|
|
|
|
|
vcs = pr_util.source_repository.scm_instance()
|
|
|
if backend.alias == "git":
|
|
|
vcs.strip(pr_util.commit_ids["new-feature"], branch_name=pr_util.backend.default_branch_name)
|
|
|
else:
|
|
|
vcs.strip(pr_util.commit_ids["new-feature"])
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pr_util.target_repository.repo_name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
assert response.status_int == 200
|
|
|
|
|
|
response.assert_response().element_contains(
|
|
|
"#changeset_compare_view_content .alert strong", "Missing commits"
|
|
|
)
|
|
|
response.assert_response().element_contains(
|
|
|
"#changeset_compare_view_content .alert",
|
|
|
"This pull request cannot be displayed, because one or more"
|
|
|
" commits no longer exist in the source repository.",
|
|
|
)
|
|
|
response.assert_response().element_contains("#update_commits", "Update commits")
|
|
|
|
|
|
def test_strip_commits_and_update(self, backend, pr_util, csrf_token):
|
|
|
commits = [
|
|
|
{"message": "initial-commit"},
|
|
|
{"message": "old-feature"},
|
|
|
{"message": "new-feature", "parents": ["old-feature"]},
|
|
|
]
|
|
|
pull_request = pr_util.create_pull_request(
|
|
|
commits,
|
|
|
target_head="old-feature",
|
|
|
source_head="new-feature",
|
|
|
revisions=["new-feature"],
|
|
|
mergeable=True,
|
|
|
)
|
|
|
pr_id = pull_request.pull_request_id
|
|
|
target_repo_name = pull_request.target_repo.repo_name
|
|
|
|
|
|
vcs = pr_util.source_repository.scm_instance()
|
|
|
if backend.alias == "git":
|
|
|
vcs.strip(pr_util.commit_ids["new-feature"], branch_name="master")
|
|
|
else:
|
|
|
vcs.strip(pr_util.commit_ids["new-feature"])
|
|
|
|
|
|
url = route_path(
|
|
|
"pullrequest_update", repo_name=target_repo_name, pull_request_id=pr_id
|
|
|
)
|
|
|
response = self.app.post(
|
|
|
url, params={"update_commits": "true", "csrf_token": csrf_token}
|
|
|
)
|
|
|
|
|
|
assert response.status_int == 200
|
|
|
assert json.loads(response.body) == json.loads(
|
|
|
'{"response": true, "redirect_url": null}'
|
|
|
)
|
|
|
|
|
|
# Make sure that after update, it won't raise 500 errors
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show", repo_name=target_repo_name, pull_request_id=pr_id
|
|
|
)
|
|
|
)
|
|
|
|
|
|
assert response.status_int == 200
|
|
|
response.assert_response().element_contains(
|
|
|
"#changeset_compare_view_content .alert strong", "Missing commits"
|
|
|
)
|
|
|
|
|
|
def test_branch_is_a_link(self, pr_util):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
pull_request.source_ref = "branch:origin:1234567890abcdef"
|
|
|
pull_request.target_ref = "branch:target:abcdef1234567890"
|
|
|
Session().add(pull_request)
|
|
|
Session().commit()
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
assert response.status_int == 200
|
|
|
|
|
|
source = response.assert_response().get_element(".pr-source-info")
|
|
|
source_parent = source.getparent()
|
|
|
assert len(source_parent) == 1
|
|
|
|
|
|
target = response.assert_response().get_element(".pr-target-info")
|
|
|
target_parent = target.getparent()
|
|
|
assert len(target_parent) == 1
|
|
|
|
|
|
expected_origin_link = route_path(
|
|
|
"repo_commits",
|
|
|
repo_name=pull_request.source_repo.scm_instance().name,
|
|
|
params=dict(branch="origin"),
|
|
|
)
|
|
|
expected_target_link = route_path(
|
|
|
"repo_commits",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
params=dict(branch="target"),
|
|
|
)
|
|
|
assert source_parent.attrib["href"] == expected_origin_link
|
|
|
assert target_parent.attrib["href"] == expected_target_link
|
|
|
|
|
|
def test_bookmark_is_not_a_link(self, pr_util):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
pull_request.source_ref = "bookmark:origin:1234567890abcdef"
|
|
|
pull_request.target_ref = "bookmark:target:abcdef1234567890"
|
|
|
Session().add(pull_request)
|
|
|
Session().commit()
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
assert response.status_int == 200
|
|
|
|
|
|
source = response.assert_response().get_element(".pr-source-info")
|
|
|
assert source.text.strip() == "bookmark:origin"
|
|
|
assert source.getparent().attrib.get("href") is None
|
|
|
|
|
|
target = response.assert_response().get_element(".pr-target-info")
|
|
|
assert target.text.strip() == "bookmark:target"
|
|
|
assert target.getparent().attrib.get("href") is None
|
|
|
|
|
|
def test_tag_is_not_a_link(self, pr_util):
|
|
|
pull_request = pr_util.create_pull_request()
|
|
|
pull_request.source_ref = "tag:origin:1234567890abcdef"
|
|
|
pull_request.target_ref = "tag:target:abcdef1234567890"
|
|
|
Session().add(pull_request)
|
|
|
Session().commit()
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
assert response.status_int == 200
|
|
|
|
|
|
source = response.assert_response().get_element(".pr-source-info")
|
|
|
assert source.text.strip() == "tag:origin"
|
|
|
assert source.getparent().attrib.get("href") is None
|
|
|
|
|
|
target = response.assert_response().get_element(".pr-target-info")
|
|
|
assert target.text.strip() == "tag:target"
|
|
|
assert target.getparent().attrib.get("href") is None
|
|
|
|
|
|
@pytest.mark.parametrize("mergeable", [True, False])
|
|
|
def test_shadow_repository_link(self, mergeable, pr_util, http_host_only_stub):
|
|
|
"""
|
|
|
Check that the pull request summary page displays a link to the shadow
|
|
|
repository if the pull request is mergeable. If it is not mergeable
|
|
|
the link should not be displayed.
|
|
|
"""
|
|
|
pull_request = pr_util.create_pull_request(
|
|
|
mergeable=mergeable, enable_notifications=False
|
|
|
)
|
|
|
target_repo = pull_request.target_repo.scm_instance()
|
|
|
pr_id = pull_request.pull_request_id
|
|
|
shadow_url = "{host}/{repo}/pull-request/{pr_id}/repository".format(
|
|
|
host=http_host_only_stub, repo=target_repo.name, pr_id=pr_id
|
|
|
)
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show", repo_name=target_repo.name, pull_request_id=pr_id
|
|
|
)
|
|
|
)
|
|
|
|
|
|
if mergeable:
|
|
|
response.assert_response().element_value_contains(
|
|
|
"input.pr-mergeinfo", shadow_url
|
|
|
)
|
|
|
response.assert_response().element_value_contains(
|
|
|
"input.pr-mergeinfo ", "pr-merge"
|
|
|
)
|
|
|
else:
|
|
|
response.assert_response().no_element_exists(".pr-mergeinfo")
|
|
|
|
|
|
|
|
|
@pytest.mark.usefixtures("app")
|
|
|
@pytest.mark.backends("git", "hg")
|
|
|
class TestPullrequestsControllerDelete(object):
|
|
|
def test_pull_request_delete_button_permissions_admin(
|
|
|
self, autologin_user, user_admin, pr_util
|
|
|
):
|
|
|
pull_request = pr_util.create_pull_request(
|
|
|
author=user_admin.username, enable_notifications=False
|
|
|
)
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
response.mustcontain('id="delete_pullrequest"')
|
|
|
response.mustcontain("Confirm to delete this pull request")
|
|
|
|
|
|
def test_pull_request_delete_button_permissions_owner(
|
|
|
self, autologin_regular_user, user_regular, pr_util
|
|
|
):
|
|
|
pull_request = pr_util.create_pull_request(
|
|
|
author=user_regular.username, enable_notifications=False
|
|
|
)
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
response.mustcontain('id="delete_pullrequest"')
|
|
|
response.mustcontain("Confirm to delete this pull request")
|
|
|
|
|
|
def test_pull_request_delete_button_permissions_forbidden(
|
|
|
self, autologin_regular_user, user_regular, user_admin, pr_util
|
|
|
):
|
|
|
pull_request = pr_util.create_pull_request(
|
|
|
author=user_admin.username, enable_notifications=False
|
|
|
)
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
response.mustcontain(no=['id="delete_pullrequest"'])
|
|
|
response.mustcontain(no=["Confirm to delete this pull request"])
|
|
|
|
|
|
def test_pull_request_delete_button_permissions_can_update_cannot_delete(
|
|
|
self, autologin_regular_user, user_regular, user_admin, pr_util, user_util
|
|
|
):
|
|
|
pull_request = pr_util.create_pull_request(
|
|
|
author=user_admin.username, enable_notifications=False
|
|
|
)
|
|
|
|
|
|
user_util.grant_user_permission_to_repo(
|
|
|
pull_request.target_repo, user_regular, "repository.write"
|
|
|
)
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(
|
|
|
"pullrequest_show",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
)
|
|
|
)
|
|
|
|
|
|
response.mustcontain('id="open_edit_pullrequest"')
|
|
|
response.mustcontain('id="delete_pullrequest"')
|
|
|
response.mustcontain(no=["Confirm to delete this pull request"])
|
|
|
|
|
|
def test_delete_comment_returns_404_if_comment_does_not_exist(
|
|
|
self, autologin_user, pr_util, user_admin, csrf_token, xhr_header
|
|
|
):
|
|
|
pull_request = pr_util.create_pull_request(
|
|
|
author=user_admin.username, enable_notifications=False
|
|
|
)
|
|
|
|
|
|
self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_delete",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
comment_id=1024404,
|
|
|
),
|
|
|
extra_environ=xhr_header,
|
|
|
params={"csrf_token": csrf_token},
|
|
|
status=404,
|
|
|
)
|
|
|
|
|
|
def test_delete_comment(
|
|
|
self, autologin_user, pr_util, user_admin, csrf_token, xhr_header
|
|
|
):
|
|
|
pull_request = pr_util.create_pull_request(
|
|
|
author=user_admin.username, enable_notifications=False
|
|
|
)
|
|
|
comment = pr_util.create_comment()
|
|
|
comment_id = comment.comment_id
|
|
|
|
|
|
response = self.app.post(
|
|
|
route_path(
|
|
|
"pullrequest_comment_delete",
|
|
|
repo_name=pull_request.target_repo.scm_instance().name,
|
|
|
pull_request_id=pull_request.pull_request_id,
|
|
|
comment_id=comment_id,
|
|
|
),
|
|
|
extra_environ=xhr_header,
|
|
|
params={"csrf_token": csrf_token},
|
|
|
status=200,
|
|
|
)
|
|
|
assert response.text == "true"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
|
"url_type",
|
|
|
[
|
|
|
"pullrequest_new",
|
|
|
"pullrequest_create",
|
|
|
"pullrequest_update",
|
|
|
"pullrequest_merge",
|
|
|
],
|
|
|
)
|
|
|
def test_pull_request_is_forbidden_on_archived_repo(
|
|
|
self, autologin_user, backend, xhr_header, user_util, url_type
|
|
|
):
|
|
|
# create a temporary repo
|
|
|
source = user_util.create_repo(repo_type=backend.alias)
|
|
|
repo_name = source.repo_name
|
|
|
repo = Repository.get_by_repo_name(repo_name)
|
|
|
repo.archived = True
|
|
|
Session().commit()
|
|
|
|
|
|
response = self.app.get(
|
|
|
route_path(url_type, repo_name=repo_name, pull_request_id=1), status=302
|
|
|
)
|
|
|
|
|
|
msg = "Action not supported for archived repository."
|
|
|
assert_session_flash(response, msg)
|
|
|
|
|
|
|
|
|
def assert_pull_request_status(pull_request, expected_status):
|
|
|
status = ChangesetStatusModel().calculated_review_status(pull_request=pull_request)
|
|
|
assert status == expected_status
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("route", ["pullrequest_new", "pullrequest_create"])
|
|
|
@pytest.mark.usefixtures("autologin_user")
|
|
|
def test_forbidde_to_repo_summary_for_svn_repositories(backend_svn, app, route):
|
|
|
app.get(route_path(route, repo_name=backend_svn.repo_name), status=404)
|
|
|
|
