def test_post_with_interdiff(self):
"""Testing the
POST review-requests/<id>/reviews/<id>/diff-comments/ API
with interdiff
"""
comment_text = "Test diff comment"
review_request, filediff = self._create_diff_review_request()
# Post the second diff.
interdiffset = self.create_diffset(review_request)
interfilediff = self.create_filediff(interdiffset)
review = self.create_review(review_request, user=self.user)
rsp = self.apiPost(
get_review_diff_comment_list_url(review),
{
'filediff_id': filediff.pk,
'interfilediff_id': interfilediff.pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': comment_text,
},
expected_mimetype=review_diff_comment_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertTrue('diff_comment' in rsp)
self.assertEqual(rsp['diff_comment']['text'], comment_text)
comment = Comment.objects.get(pk=rsp['diff_comment']['id'])
self.assertEqual(comment.filediff_id, filediff.pk)
self.assertEqual(comment.interfilediff_id, interfilediff.pk)
def test_post_with_interdiff(self):
"""Testing the
POST review-requests/<id>/reviews/<id>/diff-comments/ API
with interdiff
"""
comment_text = "Test diff comment"
review_request, filediff = self._create_diff_review_request()
# Post the second diff.
interdiffset = self.create_diffset(review_request)
interfilediff = self.create_filediff(interdiffset)
review = self.create_review(review_request, user=self.user)
rsp = self.apiPost(
get_review_diff_comment_list_url(review),
{
"filediff_id": filediff.pk,
"interfilediff_id": interfilediff.pk,
"issue_opened": True,
"first_line": 1,
"num_lines": 5,
"text": comment_text,
},
expected_mimetype=review_diff_comment_item_mimetype,
)
self.assertEqual(rsp["stat"], "ok")
self.assertTrue("diff_comment" in rsp)
self.assertEqual(rsp["diff_comment"]["text"], comment_text)
comment = Comment.objects.get(pk=rsp["diff_comment"]["id"])
self.assertEqual(comment.filediff_id, filediff.pk)
self.assertEqual(comment.interfilediff_id, interfilediff.pk)
def test_post_with_base_filediff_interdiff_dvcs_enabled_with_history(self):
"""Testing the POST <URL> API with base_filediff_id and
interfilediff_id when DVCS feature enabled
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request, filediff = self._create_diff_review_request(
with_history=True)
review = self.create_review(review_request, user=self.user)
interdiffset = self.create_diffset(review_request)
interfilediff = self.create_filediff(interdiffset)
rsp = self.api_post(
get_review_diff_comment_list_url(review),
{
'filediff_id': filediff.pk,
'base_filediff_id': filediff.pk,
'interfilediff_id': interfilediff.pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(rsp['fields'], {
'base_filediff_id': [
'This field cannot be specified with interfilediff_id.',
],
'interfilediff_id': [
'This field cannot be specified with base_filediff_id.',
],
})
def test_post_with_base_filediff_not_exists(self):
"""Testing the POST <URL> API with base_filediff_id set to a
non-existant ID
"""
self.spy_on(FileDiff.get_ancestors)
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request, filediff = self._create_diff_review_request(
with_history=True)
review = self.create_review(review_request, user=self.user)
rsp = self.api_post(
get_review_diff_comment_list_url(review),
{
'filediff_id': filediff.pk,
'base_filediff_id': 12321,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(rsp['fields'], {
'base_filediff_id': [
'This is not a valid base filediff ID.',
]
})
self.assertFalse(FileDiff.get_ancestors.called)
def test_post_with_base_filediff_dvcs_enabled_with_history_same_id(self):
"""Testing the POST <URL> API with base_filediff_id=filediff_id"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request, filediff = self._create_diff_review_request(
with_history=True)
review = self.create_review(review_request, user=self.user)
rsp = self.api_post(
get_review_diff_comment_list_url(review),
{
'filediff_id': filediff.pk,
'base_filediff_id': filediff.pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_status=400)
self.assertEqual(rsp, {
'stat': 'fail',
'err': {
'code': INVALID_FORM_DATA.code,
'msg': INVALID_FORM_DATA.msg,
},
'fields': {
'base_filediff_id': [
'This cannot be the same as filediff_id.',
],
},
})
def test_post_with_base_filediff_interdiff_dvcs_disabled(self):
"""Testing the POST <URL> API with base_filediff_id and interdiff_id
when DVCS feature disabled
"""
with override_feature_check(dvcs_feature.feature_id, enabled=False):
review_request, filediff = self._create_diff_review_request()
review = self.create_review(review_request, user=self.user)
interdiffset = self.create_diffset(review_request)
interfilediff = self.create_filediff(interdiffset)
rsp = self.api_post(
get_review_diff_comment_list_url(review),
{
'filediff_id': filediff.pk,
'base_filediff_id': filediff.pk,
'interfilediff_id': interfilediff.pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_mimetype=review_diff_comment_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('diff_comment', rsp)
item_rsp = rsp['diff_comment']
comment = Comment.objects.get(pk=item_rsp['id'])
self.compare_item(item_rsp, comment)
def test_post_with_base_filediff_dvcs_enabled_no_history(self):
"""Testing the POST <URL> API with base_filediff_id when DVCS feature
enabled and review request not created with commit history
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request, filediff = self._create_diff_review_request()
review = self.create_review(review_request, user=self.user)
rsp = self.api_post(
get_review_diff_comment_list_url(review),
{
'filediff_id': filediff.pk,
'base_filediff_id': filediff.pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(
rsp['fields']['base_filediff_id'],
['This field cannot be specified on review requests created '
'without history support.'])
def test_post_with_interfilediff_outside_diffset_history(self):
"""Testing the POST <URL> API with interfilediff_id corresponding to a
FileDiff outside the current DiffSetHistory
"""
review_request, filediff = self._create_diff_review_request()
review = self.create_review(review_request, user=self.user)
other_filediff = self._create_diff_review_request()[1]
rsp = self.api_post(
get_review_diff_comment_list_url(review),
{
'filediff_id': filediff.pk,
'interfilediff_id': other_filediff.pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(rsp['fields'], {
'interfilediff_id': ['This is not a valid interfilediff ID.'],
})
def test_post_with_issue(self):
"""Testing the
POST review-requests/<id>/reviews/<id>/diff-comments/ API
with an issue
"""
diff_comment_text = "Test diff comment with an opened issue"
review_request, filediff = self._create_diff_review_request()
review = self.create_review(review_request, user=self.user)
rsp = self.apiPost(
get_review_diff_comment_list_url(review),
{
"filediff_id": filediff.pk,
"issue_opened": True,
"first_line": 1,
"num_lines": 5,
"text": diff_comment_text,
},
expected_mimetype=review_diff_comment_item_mimetype,
)
self.assertEqual(rsp["stat"], "ok")
self.assertTrue("diff_comment" in rsp)
self.assertEqual(rsp["diff_comment"]["text"], diff_comment_text)
self.assertTrue(rsp["diff_comment"]["issue_opened"])
def test_get_diff_comments(self):
"""Testing the GET review-requests/<id>/reviews/<id>/diff-comments/ API"""
review = self._create_diff_review()
rsp = self.apiGet(get_review_diff_comment_list_url(review),
expected_mimetype=review_diff_comment_list_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertEqual(len(rsp['diff_comments']), review.comments.count())
def test_get_diff_comments_with_site(self):
"""Testing the GET review-requests/<id>/reviews/<id>/diff-comments/ API with a local site"""
review = self.test_post_diff_comments_with_site()
rsp = self.apiGet(
get_review_diff_comment_list_url(review, self.local_site_name),
expected_mimetype=review_diff_comment_list_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertEqual(len(rsp['diff_comments']), review.comments.count())
def test_get_diff_comments_with_counts_only(self):
"""Testing the GET review-requests/<id>/reviews/<id>/diff-comments/?counts-only=1 API"""
review = self._create_diff_review()
rsp = self.apiGet(get_review_diff_comment_list_url(review), {
'counts-only': 1,
}, expected_mimetype=review_diff_comment_list_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertEqual(rsp['count'], review.comments.count())
def test_get_diff_comments_with_site_no_access(self):
"""Testing the GET review-requests/<id>/reviews/<id>/diff-comments/ API with a local site and Permission Denied error"""
review = self.test_post_diff_comments_with_site()
self._login_user()
rsp = self.apiGet(
get_review_diff_comment_list_url(review, self.local_site_name),
expected_status=403)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)
def test_post_diff_comments_with_site_no_access(self):
"""Testing the POST review-requests/<id>/reviews/<id>/diff-comments/ API with a local site and Permission Denied error"""
review_request = self.create_review_request(with_local_site=True,
publish=True)
review = self.create_review(review_request, user='******', publish=True)
rsp = self.apiPost(
get_review_diff_comment_list_url(review, self.local_site_name),
{},
expected_status=403)
self.assertEqual(rsp['stat'], 'fail')
def setup_review_request_child_test(self, review_request):
if not review_request.repository_id:
# The group tests don't create a repository by default.
review_request.repository = self.create_repository()
review_request.save()
diffset = self.create_diffset(review_request)
self.create_filediff(diffset)
review = self.create_review(review_request, publish=True)
return (get_review_diff_comment_list_url(review), review_diff_comment_list_mimetype)
def test_post_diff_comments_with_interdiff(self):
"""Testing the POST review-requests/<id>/reviews/<id>/diff-comments/ API with interdiff"""
comment_text = "Test diff comment"
comment, review_request, review, interdiff_revision = \
self._common_post_interdiff_comments(comment_text)
rsp = self.apiGet(get_review_diff_comment_list_url(review),
expected_mimetype=review_diff_comment_list_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertTrue('diff_comments' in rsp)
self.assertEqual(len(rsp['diff_comments']), 1)
self.assertEqual(rsp['diff_comments'][0]['text'], comment_text)
def test_post_diff_comments_with_issue(self):
"""Testing the POST review-requests/<id>/reviews/<id>/diff-comments/ API with an issue"""
diff_comment_text = 'Test diff comment with an opened issue'
comment, review, review_request = self._create_diff_review_with_issue(
publish=False, comment_text=diff_comment_text)
rsp = self.apiGet(get_review_diff_comment_list_url(review),
expected_mimetype=review_diff_comment_list_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertTrue('diff_comments' in rsp)
self.assertEqual(len(rsp['diff_comments']), 1)
self.assertEqual(rsp['diff_comments'][0]['text'], diff_comment_text)
self.assertTrue(rsp['diff_comments'][0]['issue_opened'])
def test_get_with_counts_only(self):
"""Testing the
GET review-requests/<id>/reviews/<id>/diff-comments/?counts-only=1 API
"""
review = self._create_diff_review()
rsp = self.apiGet(
get_review_diff_comment_list_url(review),
{"counts-only": 1},
expected_mimetype=review_diff_comment_list_mimetype,
)
self.assertEqual(rsp["stat"], "ok")
self.assertEqual(rsp["count"], review.comments.count())
def test_post_with_base_filediff_outside_diffset(self):
"""Testing the POST <URL> API with base_filediff_id belonging to a
different DiffSet
"""
self.spy_on(FileDiff.get_ancestors)
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request = self.create_review_request(
create_repository=True,
create_with_history=True,
publish=True)
diffsets = [
self.create_diffset(review_request, revision=1),
self.create_diffset(review_request, revision=2)
]
commits = [
self.create_diffcommit(diffset=diffsets[0], commit_id='r1',
parent_id='r0'),
self.create_diffcommit(diffset=diffsets[1], commit_id='r2',
parent_id='r1'),
]
filediffs = [
self.create_filediff(diffset=diffset, commit=commit)
for diffset, commit in zip(diffsets, commits)
]
review = self.create_review(review_request, user=self.user)
rsp = self.api_post(
get_review_diff_comment_list_url(review),
{
'filediff_id': filediffs[1].pk,
'base_filediff_id': filediffs[0].pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(rsp['fields'], {
'base_filediff_id': [
'This is not a valid base filediff ID.',
],
})
self.assertFalse(FileDiff.get_ancestors.called)
def test_post_with_base_filediff_ancestor(self):
"""Testing the POST <URL> API with base_filediff_id belonging to
the FileDiff's set of ancestors
"""
self.spy_on(FileDiff.get_ancestors)
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request = self.create_review_request(
create_repository=True,
create_with_history=True,
publish=True)
diffset = self.create_diffset(review_request)
commits = [
self.create_diffcommit(diffset=diffset, commit_id='r1',
parent_id='r0'),
self.create_diffcommit(diffset=diffset, commit_id='r2',
parent_id='r1'),
]
filediffs = [
self.create_filediff(diffset=diffset, commit=commits[0],
source_revision='123', dest_detail='124'),
self.create_filediff(diffset=diffset, commit=commits[1],
source_revision='124', dest_detail='125'),
]
review = self.create_review(review_request, user=self.user)
rsp = self.api_post(
get_review_diff_comment_list_url(review),
{
'filediff_id': filediffs[1].pk,
'base_filediff_id': filediffs[0].pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_mimetype=review_diff_comment_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('diff_comment', rsp)
item_rsp = rsp['diff_comment']
comment = Comment.objects.get(pk=item_rsp['id'])
self.compare_item(item_rsp, comment)
self.assertTrue(FileDiff.get_ancestors.called)
def setup_basic_get_test(self, user, with_local_site, local_site_name, populate_items):
review_request = self.create_review_request(
create_repository=True, with_local_site=with_local_site, submitter=user, publish=True
)
diffset = self.create_diffset(review_request)
filediff = self.create_filediff(diffset)
review = self.create_review(review_request, publish=True)
if populate_items:
items = [self.create_diff_comment(review, filediff)]
else:
items = []
return (get_review_diff_comment_list_url(review, local_site_name), review_diff_comment_list_mimetype, items)
def setup_basic_post_test(self, user, with_local_site, local_site_name, post_valid_data):
review_request = self.create_review_request(
create_repository=True, with_local_site=with_local_site, submitter=user, publish=True
)
diffset = self.create_diffset(review_request)
filediff = self.create_filediff(diffset)
review = self.create_review(review_request, user=user)
return (
get_review_diff_comment_list_url(review, local_site_name),
review_diff_comment_item_mimetype,
{"filediff_id": filediff.pk, "text": "My new text", "first_line": 1, "num_lines": 2},
[review],
)
def test_delete_diff_comment_with_interdiff(self):
"""Testing the DELETE review-requests/<id>/reviews/<id>/diff-comments/<id>/ API"""
comment_text = "This is a test comment."
comment, review_request, review, interdiff_revision = \
self._common_post_interdiff_comments(comment_text)
self.apiDelete(get_review_diff_comment_item_url(review, comment.pk))
rsp = self.apiGet(get_review_diff_comment_list_url(review),
expected_mimetype=review_diff_comment_list_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertTrue('diff_comments' in rsp)
self.assertEqual(len(rsp['diff_comments']), 0)
def test_get_with_interdiff(self):
"""Testing the GET review-requests/<id>/reviews/<id>/diff-comments/ API
with interdiff
"""
comment_text = "Test diff comment"
comment, review_request, review, interdiff_revision = self._common_post_interdiff_comments(comment_text)
rsp = self.apiGet(
get_review_diff_comment_list_url(review),
{"interdiff-revision": interdiff_revision},
expected_mimetype=review_diff_comment_list_mimetype,
)
self.assertEqual(rsp["stat"], "ok")
self.assertTrue("diff_comments" in rsp)
self.assertEqual(len(rsp["diff_comments"]), 1)
self.assertEqual(rsp["diff_comments"][0]["text"], comment_text)
def test_post(self):
"""Testing the
POST review-requests/<id>/reviews/<id>/diff-comments/ API
"""
review_request = self.create_review_request(create_repository=True,
publish=True)
diffset = self.create_diffset(review_request)
filediff = self.create_filediff(diffset)
review = self.create_review(review_request, user=self.user)
comment = self.create_diff_comment(review, filediff)
rsp = self.apiGet(get_review_diff_comment_list_url(review),
expected_mimetype=review_diff_comment_list_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertTrue('diff_comments' in rsp)
self.assertEqual(len(rsp['diff_comments']), 1)
self.assertEqual(rsp['diff_comments'][0]['text'], comment.text)
def test_post_with_extra_fields(self):
"""Testing the
POST review-requests/<id>/reviews/<id>/diff-comments/ API
with extra fields
"""
comment_text = "This is a test comment."
extra_fields = {
'extra_data.foo': '123',
'extra_data.bar': '456',
'extra_data.baz': '',
'ignored': 'foo',
}
# Post the review request.
review_request = self.create_review_request(create_repository=True,
submitter=self.user,
publish=True)
diffset = self.create_diffset(review_request)
filediff = self.create_filediff(diffset)
# Post the review.
review = self.create_review(review_request, user=self.user)
rsp = self.apiPost(
get_review_diff_comment_list_url(review),
dict({
'filediff_id': filediff.pk,
'first_line': 1,
'num_lines': 5,
'text': comment_text,
}, **extra_fields),
expected_mimetype=review_diff_comment_item_mimetype)
comment = Comment.objects.get(pk=rsp['diff_comment']['id'])
self.assertTrue('foo' in comment.extra_data)
self.assertTrue('bar' in comment.extra_data)
self.assertFalse('baz' in comment.extra_data)
self.assertFalse('ignored' in comment.extra_data)
self.assertEqual(comment.extra_data['foo'],
extra_fields['extra_data.foo'])
self.assertEqual(comment.extra_data['bar'],
extra_fields['extra_data.bar'])
def setup_basic_get_test(self, user, with_local_site, local_site_name,
populate_items):
review_request = self.create_review_request(
create_repository=True,
with_local_site=with_local_site,
submitter=user,
publish=True)
diffset = self.create_diffset(review_request)
filediff = self.create_filediff(diffset)
review = self.create_review(review_request, publish=True)
if populate_items:
items = [self.create_diff_comment(review, filediff)]
else:
items = []
return (get_review_diff_comment_list_url(review, local_site_name),
review_diff_comment_list_mimetype,
items)
def test_post_with_extra_fields(self):
"""Testing the
POST review-requests/<id>/reviews/<id>/diff-comments/ API
with extra fields
"""
comment_text = "This is a test comment."
extra_fields = {
'extra_data.foo': '123',
'extra_data.bar': '456',
'extra_data.baz': '',
'ignored': 'foo',
}
# Post the review request.
review_request = self.create_review_request(create_repository=True,
submitter=self.user,
publish=True)
diffset = self.create_diffset(review_request)
filediff = self.create_filediff(diffset)
# Post the review.
review = self.create_review(review_request, user=self.user)
rsp = self.apiPost(get_review_diff_comment_list_url(review),
dict(
{
'filediff_id': filediff.pk,
'first_line': 1,
'num_lines': 5,
'text': comment_text,
}, **extra_fields),
expected_mimetype=review_diff_comment_item_mimetype)
comment = Comment.objects.get(pk=rsp['diff_comment']['id'])
self.assertTrue('foo' in comment.extra_data)
self.assertTrue('bar' in comment.extra_data)
self.assertFalse('baz' in comment.extra_data)
self.assertFalse('ignored' in comment.extra_data)
self.assertEqual(comment.extra_data['foo'],
extra_fields['extra_data.foo'])
self.assertEqual(comment.extra_data['bar'],
extra_fields['extra_data.bar'])
def test_post_with_base_filediff_same_commit(self):
"""Testing the POST <URL> API with base_filediff_id belonging to a
different FileDiff in the same commit
"""
self.spy_on(FileDiff.get_ancestors,
owner=FileDiff)
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request = self.create_review_request(
create_repository=True,
create_with_history=True,
publish=True)
diffset = self.create_diffset(review_request)
commit = self.create_diffcommit(diffset=diffset)
filediffs = [
self.create_filediff(diffset=diffset, commit=commit),
self.create_filediff(diffset=diffset, commit=commit),
]
review = self.create_review(review_request, user=self.user)
rsp = self.api_post(
get_review_diff_comment_list_url(review),
{
'filediff_id': filediffs[0].pk,
'base_filediff_id': filediffs[1].pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(rsp['fields'], {
'base_filediff_id': [
'This is not a valid base filediff ID.',
]
})
self.assertFalse(FileDiff.get_ancestors.called)
def test_post_with_interfilediff_same_filediff(self):
"""Testing the POST <URL> API with interfilediff_id == filediff_id"""
review_request, filediff = self._create_diff_review_request()
review = self.create_review(review_request, user=self.user)
rsp = self.api_post(get_review_diff_comment_list_url(review), {
'filediff_id': filediff.pk,
'interfilediff_id': filediff.pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(rsp['fields'], {
'interfilediff_id': ['This cannot be the same as filediff_id.'],
})
def setup_basic_post_test(self, user, with_local_site, local_site_name,
post_valid_data):
review_request = self.create_review_request(
create_repository=True,
with_local_site=with_local_site,
submitter=user,
publish=True)
diffset = self.create_diffset(review_request)
filediff = self.create_filediff(diffset)
review = self.create_review(review_request, user=user)
return (get_review_diff_comment_list_url(review, local_site_name),
review_diff_comment_item_mimetype,
{
'filediff_id': filediff.pk,
'text': 'My new text',
'first_line': 1,
'num_lines': 2,
},
[review])
def test_post_with_site(self):
"""Testing the
POST review-requests/<id>/reviews/<id>/diff-comments/ API
with a local site
"""
review_request, filediff = \
self._create_diff_review_request(with_local_site=True)
user = self._login_user(local_site=True)
review = self.create_review(review_request, user=user)
comment = self.create_diff_comment(review, filediff)
rsp = self.apiGet(
get_review_diff_comment_list_url(review, self.local_site_name),
expected_mimetype=review_diff_comment_list_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertTrue('diff_comments' in rsp)
self.assertEqual(len(rsp['diff_comments']), 1)
self.assertEqual(rsp['diff_comments'][0]['text'], comment.text)
return review
def test_post_diff_comments_with_site(self):
"""Testing the POST review-requests/<id>/reviews/<id>/diff-comments/ API with a local site"""
diff_comment_text = "Test diff comment"
review_request, filediff = \
self._create_diff_review_request(with_local_site=True)
user = self._login_user(local_site=True)
review = self.create_review(review_request, user=user)
self._postNewDiffComment(review_request, review.pk, diff_comment_text)
rsp = self.apiGet(
get_review_diff_comment_list_url(review, self.local_site_name),
expected_mimetype=review_diff_comment_list_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertTrue('diff_comments' in rsp)
self.assertEqual(len(rsp['diff_comments']), 1)
self.assertEqual(rsp['diff_comments'][0]['text'], diff_comment_text)
return review
def _postNewDiffComment(self, review_request, review_id, comment_text,
filediff_id=None, interfilediff_id=None,
first_line=10, num_lines=5, issue_opened=None,
issue_status=None):
"""Creates a diff comment and returns the payload response."""
if filediff_id is None:
diffset = review_request.diffset_history.diffsets.latest()
filediff = diffset.files.all()[0]
filediff_id = filediff.id
data = {
'filediff_id': filediff_id,
'text': comment_text,
'first_line': first_line,
'num_lines': num_lines,
}
if interfilediff_id is not None:
data['interfilediff_id'] = interfilediff_id
if issue_opened is not None:
data['issue_opened'] = issue_opened
if issue_status is not None:
data['issue_status'] = issue_status
if review_request.local_site:
local_site_name = review_request.local_site.name
else:
local_site_name = None
review = Review.objects.get(pk=review_id)
rsp = self.api_post(
get_review_diff_comment_list_url(review, local_site_name),
data,
expected_mimetype=review_diff_comment_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
return rsp
def _postNewDiffComment(self, review_request, review_id, comment_text,
filediff_id=None, interfilediff_id=None,
first_line=10, num_lines=5, issue_opened=None,
issue_status=None):
"""Creates a diff comment and returns the payload response."""
if filediff_id is None:
diffset = review_request.diffset_history.diffsets.latest()
filediff = diffset.files.all()[0]
filediff_id = filediff.id
data = {
'filediff_id': filediff_id,
'text': comment_text,
'first_line': first_line,
'num_lines': num_lines,
}
if interfilediff_id is not None:
data['interfilediff_id'] = interfilediff_id
if issue_opened is not None:
data['issue_opened'] = issue_opened
if issue_status is not None:
data['issue_status'] = issue_status
if review_request.local_site:
local_site_name = review_request.local_site.name
else:
local_site_name = None
review = Review.objects.get(pk=review_id)
rsp = self.apiPost(
get_review_diff_comment_list_url(review, local_site_name),
data,
expected_mimetype=review_diff_comment_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
return rsp
def test_post_with_issue(self):
"""Testing the
POST review-requests/<id>/reviews/<id>/diff-comments/ API
with an issue
"""
diff_comment_text = 'Test diff comment with an opened issue'
review_request, filediff = self._create_diff_review_request()
review = self.create_review(review_request, user=self.user)
rsp = self.apiPost(get_review_diff_comment_list_url(review), {
'filediff_id': filediff.pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': diff_comment_text,
},
expected_mimetype=review_diff_comment_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertTrue('diff_comment' in rsp)
self.assertEqual(rsp['diff_comment']['text'], diff_comment_text)
self.assertTrue(rsp['diff_comment']['issue_opened'])
def test_post_with_interfilediff_same_filediff(self):
"""Testing the POST <URL> API with interfilediff_id == filediff_id"""
review_request, filediff = self._create_diff_review_request()
review = self.create_review(review_request, user=self.user)
rsp = self.api_post(
get_review_diff_comment_list_url(review),
{
'filediff_id': filediff.pk,
'interfilediff_id': filediff.pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(rsp['fields'], {
'interfilediff_id': ['This cannot be the same as filediff_id.'],
})
def test_post_with_interfilediff_outside_diffset_history(self):
"""Testing the POST <URL> API with interfilediff_id corresponding to a
FileDiff outside the current DiffSetHistory
"""
review_request, filediff = self._create_diff_review_request()
review = self.create_review(review_request, user=self.user)
other_filediff = self._create_diff_review_request()[1]
rsp = self.api_post(get_review_diff_comment_list_url(review), {
'filediff_id': filediff.pk,
'interfilediff_id': other_filediff.pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(rsp['fields'], {
'interfilediff_id': ['This is not a valid interfilediff ID.'],
})
def test_post_with_base_filediff_dvcs_enabled_no_history(self):
"""Testing the POST <URL> API with base_filediff_id when DVCS feature
enabled and review request not created with commit history
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request, filediff = self._create_diff_review_request()
review = self.create_review(review_request, user=self.user)
rsp = self.api_post(get_review_diff_comment_list_url(review), {
'filediff_id': filediff.pk,
'base_filediff_id': filediff.pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': 'foo',
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(rsp['fields']['base_filediff_id'], [
'This field cannot be specified on review requests created '
'without history support.'
])
def test_post_with_issue(self):
"""Testing the
POST review-requests/<id>/reviews/<id>/diff-comments/ API
with an issue
"""
diff_comment_text = 'Test diff comment with an opened issue'
review_request, filediff = self._create_diff_review_request()
review = self.create_review(review_request, user=self.user)
rsp = self.apiPost(
get_review_diff_comment_list_url(review),
{
'filediff_id': filediff.pk,
'issue_opened': True,
'first_line': 1,
'num_lines': 5,
'text': diff_comment_text,
},
expected_mimetype=review_diff_comment_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertTrue('diff_comment' in rsp)
self.assertEqual(rsp['diff_comment']['text'], diff_comment_text)
self.assertTrue(rsp['diff_comment']['issue_opened'])
