def test_post_with_history(self):
"""Testing the POST <URL> API with a diff and a review request created
with history support
"""
review_request = self.create_review_request(submitter=self.user,
create_repository=True,
create_with_history=True)
diff = SimpleUploadedFile('diff',
self.DEFAULT_GIT_FILEDIFF_DATA_DIFF,
content_type='text/x-patch')
with override_feature_check(dvcs_feature.feature_id, enabled=True):
rsp = self.api_post(get_diff_list_url(review_request), {
'path': diff,
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(
rsp['reason'],
'This review request was created with support for multiple '
'commits.\n\n'
'Create an empty diff revision and upload commits to that '
'instead.')
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_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_commit_filter_no_results(self):
"""Testing the GET <URL>?commit-id= API with no results"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
repository = self.create_repository()
review_request = self.create_review_request(
repository=repository,
submitter=self.user,
create_with_history=True)
diffset = self.create_diffset(review_request=review_request,
repository=repository)
commit = self.create_diffcommit(diffset=diffset,
repository=repository)
diffset.finalize_commit_series(
cumulative_diff=self.DEFAULT_GIT_FILEDIFF_DATA_DIFF,
validation_info=None,
validate=False,
save=True)
rsp = self.api_get(
'%s?commit-id=%s'
% (get_filediff_list_url(diffset, review_request),
commit.parent_id),
expected_status=200,
expected_mimetype=filediff_list_mimetype)
self.assertIn('stat', rsp)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('files', rsp)
self.assertEqual(rsp['files'], [])
self.assertEqual(rsp['total_results'], 0)
def test_put_finalize_empty_commit_series(self):
"""Testing the PUT <URL> API with finalize_commit_series=1 for an empty
commit series
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request = self.create_review_request(
create_repository=True,
create_with_history=True,
submitter=self.user)
diffset = self.create_diffset(review_request=review_request,
draft=True)
cumulative_diff = SimpleUploadedFile('diff',
b'',
content_type='text/x-patch')
rsp = self.api_put(
get_draft_diff_item_url(review_request, diffset.revision), {
'finalize_commit_series': True,
'cumulative_diff': cumulative_diff,
'validation_info': serialize_validation_info({}),
},
expected_status=400)
self.assertEqual(
rsp, {
'stat': 'fail',
'err': {
'code': INVALID_ATTRIBUTE.code,
'msg': INVALID_ATTRIBUTE.msg,
},
'reason': 'Cannot finalize an empty commit series.',
})
def test_history_no_commit_filter(self):
"""Testing the GET <URL> API for a diffset with commits only returns
cumulative files
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
repository = self.create_repository()
review_request = self.create_review_request(
repository=repository,
submitter=self.user,
create_with_history=True)
diffset = self.create_diffset(review_request=review_request,
repository=repository)
commit = self.create_diffcommit(diffset=diffset,
repository=repository)
diffset.finalize_commit_series(
cumulative_diff=self.DEFAULT_GIT_FILEDIFF_DATA_DIFF,
validation_info=None,
validate=False,
save=True)
cumulative_filediff = diffset.cumulative_files[0]
rsp = self.api_get(get_filediff_list_url(diffset, review_request),
expected_mimetype=filediff_list_mimetype)
self.assertIn('stat', rsp)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('files', rsp)
self.assertEqual(rsp['total_results'], 1)
self.assertEqual(rsp['files'][0]['id'], cumulative_filediff.pk)
self.assertNotEqual(commit.files.get().pk, cumulative_filediff.pk)
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_filter_interdiff_opcodes_v2_with_trailing_context(self):
"""Testing filter_interdiff_opcodes (v2) with trailing context"""
opcodes = [
('replace', 0, 13, 0, 13),
('insert', 13, 13, 13, 14),
('replace', 13, 20, 14, 21),
]
self._sanity_check_opcodes(opcodes)
orig_diff = self._build_dummy_diff_data(10, 5, 10, 6)
new_diff = self._build_dummy_diff_data(10,
6,
10,
7,
pre_lines_of_context=4)
with override_feature_check(filter_interdiffs_v2_feature,
enabled=True):
new_opcodes = list(
filter_interdiff_opcodes(opcodes, orig_diff, new_diff))
self.assertEqual(new_opcodes, [
('filtered-equal', 0, 13, 0, 13),
('insert', 13, 13, 13, 14),
('filtered-equal', 13, 20, 14, 21),
])
self._sanity_check_opcodes(new_opcodes)
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_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_commit_filter(self):
"""Testing the GET <URL>?commit-id= API filters FileDiffs to the
requested commit
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
repository = self.create_repository()
review_request = self.create_review_request(repository=repository,
submitter=self.user)
diffset = self.create_diffset(review_request=review_request,
repository=repository)
commit = self.create_diffcommit(diffset=diffset,
repository=repository)
diffset.finalize_commit_series(
cumulative_diff=self.DEFAULT_GIT_FILEDIFF_DATA_DIFF,
validation_info=None,
validate=False,
save=True)
rsp = self.api_get('%s?commit-id=%s' % (get_filediff_list_url(
diffset, review_request), commit.commit_id),
expected_status=200,
expected_mimetype=filediff_list_mimetype)
self.assertIn('stat', rsp)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('files', rsp)
self.assertEqual(rsp['total_results'], 1)
item_rsp = rsp['files'][0]
filediff = FileDiff.objects.get(pk=item_rsp['id'])
self.compare_item(item_rsp, filediff)
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_put_finalize_dvcs_feature_disabled(self):
"""Testing the PUT <URL> API with finalize_commit_series=1 when the
DVCS feature is disabled
"""
with override_feature_check(dvcs_feature.feature_id, enabled=False):
review_request = self.create_review_request(
create_repository=True,
submitter=self.user)
diffset = self.create_diffset(review_request=review_request,
draft=True)
cumulative_diff = SimpleUploadedFile('diff', b'',
content_type='text/x-patch')
rsp = self.api_put(
get_draft_diff_item_url(review_request, diffset.revision),
{
'finalize_commit_series': True,
'cumulative_diff': cumulative_diff,
'validation_info': serialize_validation_info({}),
},
expected_mimetype=diff_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.compare_item(rsp['diff'], diffset)
def test_post_with_history(self):
"""Testing the POST <URL> API with a diff and a review request created
with history support
"""
review_request = self.create_review_request(submitter=self.user,
create_repository=True,
create_with_history=True)
diff = SimpleUploadedFile('diff',
self.DEFAULT_GIT_FILEDIFF_DATA_DIFF,
content_type='text/x-patch')
with override_feature_check(dvcs_feature.feature_id, enabled=True):
rsp = self.api_post(
get_diff_list_url(review_request),
{
'path': diff,
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(
rsp['reason'],
'This review request was created with support for multiple '
'commits.\n\n'
'Create an empty diff revision and upload commits to that '
'instead.')
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_filter_interdiff_v2_opcodes(self):
"""Testing filter_interdiff_opcodes (v2)"""
opcodes = [
('insert', 0, 0, 0, 1),
('equal', 0, 5, 1, 6),
('delete', 5, 10, 6, 6),
('equal', 10, 25, 6, 21),
('replace', 25, 26, 21, 22),
('equal', 26, 40, 22, 36),
('insert', 40, 40, 36, 46),
]
self._sanity_check_opcodes(opcodes)
orig_diff = self._build_dummy_diff_data(22, 10, 22, 10)
new_diff = b''.join([
self._build_dummy_diff_data(2, 14, 2, 9),
self._build_dummy_diff_data(22, 10, 22, 10),
])
with override_feature_check(filter_interdiffs_v2_feature,
enabled=True):
new_opcodes = list(
filter_interdiff_opcodes(opcodes, orig_diff, new_diff))
self.assertEqual(new_opcodes, [
('filtered-equal', 0, 0, 0, 1),
('filtered-equal', 0, 5, 1, 6),
('filtered-equal', 5, 10, 6, 6),
('equal', 10, 25, 6, 21),
('replace', 25, 26, 21, 22),
('equal', 26, 28, 22, 24),
('filtered-equal', 28, 40, 24, 36),
('filtered-equal', 40, 40, 36, 46),
])
self._sanity_check_opcodes(new_opcodes)
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_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_commit_filter_no_results(self):
"""Testing the GET <URL>?commit-id= API with no results"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
repository = self.create_repository()
review_request = self.create_review_request(
repository=repository,
submitter=self.user,
create_with_history=True)
diffset = self.create_diffset(review_request=review_request,
repository=repository)
commit = self.create_diffcommit(diffset=diffset,
repository=repository)
diffset.finalize_commit_series(
cumulative_diff=self.DEFAULT_GIT_FILEDIFF_DATA_DIFF,
validation_info=None,
validate=False,
save=True)
rsp = self.api_get('%s?commit-id=%s' % (get_filediff_list_url(
diffset, review_request), commit.parent_id),
expected_status=200,
expected_mimetype=filediff_list_mimetype)
self.assertIn('stat', rsp)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('files', rsp)
self.assertEqual(rsp['files'], [])
self.assertEqual(rsp['total_results'], 0)
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_commit_filter(self):
"""Testing the GET <URL>?commit-id= API filters FileDiffs to the
requested commit
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
repository = self.create_repository()
review_request = self.create_review_request(repository=repository,
submitter=self.user)
diffset = self.create_diffset(review_request=review_request,
repository=repository)
commit = self.create_diffcommit(diffset=diffset,
repository=repository)
diffset.finalize_commit_series(
cumulative_diff=self.DEFAULT_GIT_FILEDIFF_DATA_DIFF,
validation_info=None,
validate=False,
save=True)
rsp = self.api_get(
'%s?commit-id=%s'
% (get_filediff_list_url(diffset, review_request),
commit.commit_id),
expected_status=200,
expected_mimetype=filediff_list_mimetype)
self.assertIn('stat', rsp)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('files', rsp)
self.assertEqual(rsp['total_results'], 1)
item_rsp = rsp['files'][0]
filediff = FileDiff.objects.get(pk=item_rsp['id'])
self.compare_item(item_rsp, filediff)
def test_put_finalized_with_parent(self):
"""Testing the PUT <URL> API with finalize_commit_series=1 and a parent
diff
"""
def _get_file_exists(repository,
path,
revision,
base_commit_id=None,
request=None):
self.assertEqual(path, 'README')
self.assertEqual(revision, 'f00f00')
return True
self.spy_on(Repository.get_file_exists, call_fake=_get_file_exists)
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request = self.create_review_request(
create_repository=True,
create_with_history=True,
submitter=self.user)
diffset = self.create_diffset(review_request=review_request,
draft=True)
commit = self.create_diffcommit(diffset=diffset)
filediff = FileDiff.objects.get()
filediff.parent_diff = (b'diff --git a/README b/README\n'
b'index f00f00..94bdd3e\n'
b'--- a/README\n'
b'+++ b/README\n')
filediff.extra_data[FileDiff._IS_PARENT_EMPTY_KEY] = True
filediff.save(update_fields=('extra_data', ))
cumulative_diff = SimpleUploadedFile('diff',
filediff.diff,
content_type='text/x-patch')
parent_diff = SimpleUploadedFile('parent_diff',
filediff.parent_diff,
content_type='text/x-patch')
validation_info = update_validation_info(
{},
commit_id=commit.commit_id,
parent_id=commit.parent_id,
filediffs=[filediff])
rsp = self.api_put(
get_draft_diff_item_url(review_request, diffset.revision), {
'finalize_commit_series': True,
'cumulative_diff': cumulative_diff,
'parent_diff': parent_diff,
'validation_info':
serialize_validation_info(validation_info),
},
expected_mimetype=diff_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.compare_item(rsp['diff'], diffset)
def def_test_delete_superuser(self):
"""Testing the DELETE <URL> API as a superuser"""
url, (pk, ) = self.setup_basic_delete_test(self.user, False, None)
self._login_user(admin=True)
with override_feature_check(oauth2_service_feature.feature_id, True):
self.api_delete(url, expected_status=204)
self.check_put_result(self.user, pk)
def def_test_delete_superuser(self):
"""Testing the DELETE <URL> API as a superuser"""
url, (pk,) = self.setup_basic_delete_test(self.user, False, None)
self._login_user(admin=True)
with override_feature_check(oauth2_service_feature.feature_id, True):
self.api_delete(url, expected_status=204)
self.check_put_result(self.user, pk)
def test_put_finalize_adds_default_reviewers(self):
"""Testing the PUT <URL> API with finalize_commit_series=1 adds
default reviewers
"""
@self.spy_for(Repository.get_file_exists, owner=Repository)
def _get_file_exists(repository, path, revision, **kwargs):
self.assertEqual(path, 'README')
self.assertEqual(revision, '94bdd3e')
return True
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request = self.create_review_request(
create_repository=True,
create_with_history=True,
submitter=self.user)
# Create the state needed for the default reviewer.
group = self.create_review_group(name='group1')
default_reviewer = DefaultReviewer.objects.create(name='default1',
file_regex='.')
default_reviewer.groups.add(group)
default_reviewer.repository.add(review_request.repository)
# Create the state needed for the diff to post.
diffset = self.create_diffset(review_request=review_request,
draft=True)
commit = self.create_diffcommit(diffset=diffset)
filediff = FileDiff.objects.get()
cumulative_diff = SimpleUploadedFile('diff',
filediff.diff,
content_type='text/x-patch')
validation_info = update_validation_info(
{},
commit_id=commit.commit_id,
parent_id=commit.parent_id,
filediffs=[filediff])
# Post the diff.
rsp = self.api_put(
get_draft_diff_item_url(review_request, diffset.revision), {
'finalize_commit_series': True,
'cumulative_diff': cumulative_diff,
'validation_info':
serialize_validation_info(validation_info),
},
expected_mimetype=diff_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.compare_item(rsp['diff'], diffset)
draft = review_request.get_draft()
self.assertEqual(list(draft.target_groups.all()), [group])
def test_put_finalize_validation_info_missing_commits(self):
"""Testing the PUT <URL> API with finalize_commit_series=1 when
validation_info does not contain all commits
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request = self.create_review_request(
create_repository=True,
create_with_history=True,
submitter=self.user)
diffset = self.create_diffset(review_request=review_request,
draft=True)
commits = [
self.create_diffcommit(diffset=diffset, **kwargs)
for kwargs in (
{'commit_id': 'r1', 'parent_id': 'r0'},
{'commit_id': 'r2', 'parent_id': 'r1'},
)
]
filediff = commits[0].files.first()
validation_info = update_validation_info(
{},
commit_id=commits[0].commit_id,
parent_id=commits[0].parent_id,
filediffs=[filediff])
cumulative_diff = SimpleUploadedFile('diff', filediff.diff,
content_type='text/x-patch')
rsp = self.api_put(
get_draft_diff_item_url(review_request, diffset.revision),
{
'finalize_commit_series': True,
'cumulative_diff': cumulative_diff,
'validation_info': serialize_validation_info(
validation_info),
},
expected_status=400)
self.assertEqual(rsp, {
'stat': 'fail',
'err': {
'code': INVALID_FORM_DATA.code,
'msg': INVALID_FORM_DATA.msg,
},
'fields': {
'validation_info': [
'The following commits exist but are not present in '
'validation_info: r2',
],
}
})
def test_get_superuser(self):
"""Testing the GET <URL> API as a superuser"""
url, mimetype, token = self.setup_basic_get_test(
self.user, False, None)
self._login_user(admin=True)
with override_feature_check(oauth2_service_feature.feature_id, True):
rsp = self.api_get(url, expected_mimetype=mimetype)
self.assertIn('oauth_token', rsp)
self.compare_item(rsp['oauth_token'], token)
def test_put_superuser(self):
"""Testing the PUT <URL> API as a superuser"""
url, mimetype, request_data, token = self.setup_basic_put_test(
self.user, False, None, True)[:-1]
self._login_user(admin=True)
with override_feature_check(oauth2_service_feature.feature_id, True):
rsp = self.api_get(url, request_data, expected_mimetype=mimetype)
self.assertIn('oauth_token', rsp)
self.check_put_result(self.user, rsp['oauth_token'], token)
def test_put_superuser(self):
"""Testing the PUT <URL> API as a superuser"""
url, mimetype, request_data, token = self.setup_basic_put_test(
self.user, False, None, True)[:-1]
self._login_user(admin=True)
with override_feature_check(oauth2_service_feature.feature_id, True):
rsp = self.api_get(url, request_data, expected_mimetype=mimetype)
self.assertIn('oauth_token', rsp)
self.check_put_result(self.user, rsp['oauth_token'], token)
def test_override_feature_check(self):
"""Testing override_feature_check"""
stable_feature = StableFeature()
experimental_feature = ExperimentalFeature()
self.assertTrue(stable_feature.is_enabled())
self.assertFalse(experimental_feature.is_enabled())
with override_feature_check(stable_feature.feature_id, enabled=False):
self.assertFalse(stable_feature.is_enabled())
self.assertFalse(experimental_feature.is_enabled())
with override_feature_check(experimental_feature.feature_id,
enabled=True):
self.assertTrue(stable_feature.is_enabled())
self.assertTrue(experimental_feature.is_enabled())
# Make sure they haven't been permanently overridden.
self.assertTrue(stable_feature.is_enabled())
self.assertFalse(experimental_feature.is_enabled())
def test_get_superuser(self):
"""Testing the GET <URL> API as a superuser"""
url, mimetype, token = self.setup_basic_get_test(self.user, False,
None)
self._login_user(admin=True)
with override_feature_check(oauth2_service_feature.feature_id, True):
rsp = self.api_get(url, expected_mimetype=mimetype)
self.assertIn('oauth_token', rsp)
self.compare_item(rsp['oauth_token'], token)
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 def_test_delete_superuser_local_site(self):
"""Testing the DELETE <URL> API with access to a Local Site as a
superuser
"""
url, (pk,) = self.setup_basic_delete_test(self.user, True,
self.local_site_name)
self._login_user(admin=True)
with override_feature_check(oauth2_service_feature.feature_id, True):
self.api_delete(url, expected_status=204)
self.check_put_result(self.user, pk)
def def_test_delete_superuser_local_site(self):
"""Testing the DELETE <URL> API with access to a Local Site as a
superuser
"""
url, (pk, ) = self.setup_basic_delete_test(self.user, True,
self.local_site_name)
self._login_user(admin=True)
with override_feature_check(oauth2_service_feature.feature_id, True):
self.api_delete(url, expected_status=204)
self.check_put_result(self.user, pk)
def test_put_finalize_validation_info_extra_commits(self):
"""Testing the PUT <URL> API with finalize_commit_series=1 when
validation_info contains commits that do not exist
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request = self.create_review_request(
create_repository=True,
create_with_history=True,
submitter=self.user)
diffset = self.create_diffset(review_request=review_request,
draft=True)
commit = self.create_diffcommit(diffset=diffset)
filediff = commit.files.first()
validation_info = update_validation_info(
{},
commit_id=commit.commit_id,
parent_id=commit.parent_id,
filediffs=[filediff])
validation_info = update_validation_info(
validation_info,
commit_id='f00',
parent_id=commit.commit_id,
filediffs=[])
cumulative_diff = SimpleUploadedFile('diff',
filediff.diff,
content_type='text/x-patch')
rsp = self.api_put(
get_draft_diff_item_url(review_request, diffset.revision), {
'finalize_commit_series': True,
'cumulative_diff': cumulative_diff,
'validation_info':
serialize_validation_info(validation_info),
},
expected_status=400)
self.assertEqual(
rsp, {
'stat': 'fail',
'err': {
'code': INVALID_FORM_DATA.code,
'msg': INVALID_FORM_DATA.msg,
},
'fields': {
'validation_info': [
'The following commits are specified in validation_info '
'but do not exist: f00'
],
},
})
def test_review_request_dropdown_action_hook(self):
"""Testing ReviewRequestDropdownActionHook renders on a review request
page but not on a file attachment or a diff viewer page
"""
with override_feature_check(ClassBasedActionsFeature.feature_id,
enabled=True):
self._test_review_request_dropdown_action_hook(
'review-request-detail', ReviewRequestDropdownActionHook, True)
self._test_review_request_dropdown_action_hook(
'file-attachment', ReviewRequestDropdownActionHook, False)
self._test_review_request_dropdown_action_hook(
'view-diff', ReviewRequestDropdownActionHook, False)
def test_post_with_base_filediff_outside_history(self):
"""Testing the POST <URL> API with base_filediff_id not 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_file='/foo',
dest_file='/foo'),
self.create_filediff(diffset=diffset,
commit=commits[1],
source_file='/bar',
dest_file='/bar'),
]
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.assertTrue(FileDiff.get_ancestors.called)
def test_get_superuser_local_site(self):
"""Testing the GET <URL> API with access to a Local Site as a superuser
"""
url, mimetype, tokens = self.setup_basic_get_test(
self.user, True, self.local_site_name, True)
self._login_user(admin=True)
with override_feature_check(oauth2_service_feature.feature_id, True):
rsp = self.api_get(url, expected_mimetype=mimetype)
self.assertIn('oauth_tokens', rsp)
self.assertEqual(len(rsp['oauth_tokens']), 1)
self.compare_item(rsp['oauth_tokens'][0], tokens[0])
def test_auth(self):
"""Testing OAuth2 authentication to the Web API with a valid token"""
application = self.create_oauth_application(user=self.owner)
token = self.create_oauth_token(application, self.user, 'session:read')
with override_feature_check(oauth2_service_feature.feature_id, True):
load_site_config()
rsp = self.api_get(get_session_url(),
HTTP_AUTHORIZATION='Bearer %s' % token.token,
expected_mimetype=session_mimetype)
self.assertIn('stat', rsp)
self.assertEqual(rsp['stat'], 'ok')
def test_get_superuser_local_site(self):
"""Testing the GET <URL> API with access to a Local Site as a superuser
"""
url, mimetype, tokens = self.setup_basic_get_test(
self.user, True, self.local_site_name, True)
self._login_user(admin=True)
with override_feature_check(oauth2_service_feature.feature_id, True):
rsp = self.api_get(url, expected_mimetype=mimetype)
self.assertIn('oauth_tokens', rsp)
self.assertEqual(len(rsp['oauth_tokens']), 1)
self.compare_item(rsp['oauth_tokens'][0], tokens[0])
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_auth_invalid_scope(self):
"""Testing OAuth2 authentication to the Web API with a token missing
scopes"""
application = self.create_oauth_application(user=self.owner)
token = self.create_oauth_token(application, self.user)
with override_feature_check(oauth2_service_feature.feature_id, True):
load_site_config()
rsp = self.api_get(get_session_url(),
HTTP_AUTHORIZATION='Bearer %s' % token.token,
expected_status=403)
self.assertIn('stat', rsp)
self.assertEqual(rsp['stat'], 'fail')
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 test_get_capability_dvcs_disabled(self):
"""Testing the GET / API for capabilities with the DVCS feature
disabled
"""
with override_feature_check(dvcs_feature.feature_id, False):
self.assertFalse(dvcs_feature.is_enabled())
rsp = self.api_get(get_root_url(),
expected_mimetype=root_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('capabilities', rsp)
caps = rsp['capabilities']
self.assertIn('review_requests', caps)
self.assertNotIn('supports_history', caps['review_requests'])
def test_auth_expired(self):
"""Testing OAuth2 authentication to the Web API with an expired token
"""
application = self.create_oauth_application(user=self.owner)
token = self.create_oauth_token(application, self.user, 'session:read',
expires=timedelta(hours=-1))
with override_feature_check(oauth2_service_feature.feature_id, True):
load_site_config()
rsp = self.api_get(get_session_url(),
HTTP_AUTHORIZATION='Bearer %s' % token.token,
expected_status=401)
self.assertIn('stat', rsp)
self.assertEqual(rsp['stat'], 'fail')
def test_auth_no_local_site(self):
"""Testing OAuth2 authentication to the Web API of a Local Site with an
application not on that Local Site
"""
local_site = LocalSite.objects.get(pk=1)
local_site.users.add(self.user)
application = self.create_oauth_application(user=self.owner)
token = self.create_oauth_token(application, self.user, 'session:read')
with override_feature_check(oauth2_service_feature.feature_id, True):
load_site_config()
rsp = self.api_get(get_session_url(local_site.name),
HTTP_AUTHORIZATION='Bearer %s' % token.token,
expected_status=401)
self.assertIn('stat', rsp)
self.assertEqual(rsp['stat'], 'fail')
def test_publish_without_history_not_finalized(self):
"""Testing ReviewRequestDraft.publish for a review request created
without commit history support when the diffset has not been finalized
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request = self.create_review_request(
create_repository=True)
diffset = self.create_diffset(review_request, draft=True)
draft = review_request.get_draft()
draft.target_people = [review_request.submitter]
self.create_filediff(diffset=diffset)
draft.publish()
review_request = ReviewRequest.objects.get(pk=review_request.pk)
self.assertEqual(review_request.status,
ReviewRequest.PENDING_REVIEW)
def test_post_empty_dvcs_disabled(self):
"""Testing the POST <URL> API without a diff with the DVCS feature
disabled
"""
review_request = self.create_review_request(submitter=self.user,
create_repository=True,
create_with_history=False)
with override_feature_check(dvcs_feature.feature_id, enabled=False):
rsp = self.api_post(get_diff_list_url(review_request), {},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertEqual(rsp['fields'], {
'path': ['This field is required.'],
})
def test_disable_reassign_to_admin(self):
"""Testing an Application is disabled and re-assigned to a Local Site
admin when its owner is removed from a Local Site
"""
with override_feature_check(oauth2_service_feature.feature_id, True):
local_site = LocalSite.objects.get(pk=1)
user = User.objects.get(username='******')
admin = User.objects.get(username='******')
application = self.create_oauth_application(user=user,
local_site=local_site)
local_site.users.remove(user)
application = Application.objects.get(pk=application.pk)
self.assertTrue(application.is_disabled_for_security)
self.assertEqual(application.original_user_id, user.pk)
self.assertEqual(application.user_id, admin.pk)
self.assertFalse(application.enabled)
def test_publish_with_history_diffset_not_finalized(self):
"""Testing ReviewRequestDraft.publish for a review request created with
commit history support when the diffset has not been finalized
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request = self.create_review_request(
create_with_history=True,
create_repository=True)
self.create_diffset(review_request, draft=True)
draft = review_request.get_draft()
draft.target_people = [review_request.submitter]
error_msg = \
'Error publishing: There are no commits attached to the diff'
with self.assertRaisesMessage(PublishError, error_msg):
draft.publish()
def test_feature_require_enabled(self):
"""Testing @feature_required with an enabled feature"""
feature = DummyFeature()
self.assertFalse(feature.is_enabled())
def view(request):
return HttpResponse(content=b'foo')
decorated = feature_required(feature)(view)
self.spy_on(view)
with override_feature_check(feature.feature_id, enabled=True):
self.assertTrue(feature.is_enabled())
result = decorated(None)
self.assertIsInstance(result, HttpResponse)
self.assertEqual(result.content, b'foo')
self.assertTrue(view.spy.called)
def test_post_empty_with_history(self):
"""Testing the POST <URL> API creates an empty DiffSet for a review
request created with history support with the DVCS feature enabled
"""
review_request = self.create_review_request(submitter=self.user,
create_repository=True,
create_with_history=True)
with override_feature_check(dvcs_feature.feature_id, enabled=True):
rsp = self.api_post(get_diff_list_url(review_request), {},
expected_mimetype=diff_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
item_rsp = rsp['diff']
diff = DiffSet.objects.get(pk=item_rsp['id'])
self.compare_item(item_rsp, diff)
self.assertEqual(diff.files.count(), 0)
self.assertEqual(diff.revision, 1)
def test_get_links_fields_dvcs_disabled(self):
"""Testing the GET <URL> API does not includes DVCS-specific fields and
links when the DVCS feature is enabled
"""
review_request = self.create_review_request(create_repository=True,
publish=True)
diffset = self.create_diffset(review_request)
with override_feature_check(dvcs_feature.feature_id, enabled=False):
rsp = self.api_get(get_diff_item_url(review_request,
diffset.revision),
expected_mimetype=diff_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('diff', rsp)
item_rsp = rsp['diff']
self.assertIn('links', item_rsp)
self.assertNotIn('commits', item_rsp['links'])
self.assertNotIn('commit_count', item_rsp)
def test_auth_local_site_member(self):
"""Testing OAuth2 authentication to the Web API of a Local Site with
with an application on a that Local Site as a member
"""
local_site = LocalSite.objects.get(pk=1)
local_site.users.add(self.user)
local_site.save(update_fields=('public',))
self.assertTrue(local_site.is_accessible_by(self.user))
application = self.create_oauth_application(user=self.owner,
local_site=local_site)
token = self.create_oauth_token(application, self.user, 'session:read')
with override_feature_check(oauth2_service_feature.feature_id, True):
load_site_config()
rsp = self.api_get(get_session_url(local_site.name),
HTTP_AUTHORIZATION='Bearer %s' % token.token,
expected_mimetype=session_mimetype)
self.assertIn('stat', rsp)
self.assertEqual(rsp['stat'], 'ok')
def test_publish_with_history_diffset_finalized(self):
"""Testing ReviewRequestDraft.publish for a review request created with
commit history support when the diffset has been finalized
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
review_request = self.create_review_request(
create_with_history=True,
create_repository=True)
diffset = self.create_diffset(review_request=review_request,
draft=True)
self.create_diffcommit(diffset=diffset)
diffset.finalize_commit_series(
cumulative_diff=self.DEFAULT_GIT_FILEDIFF_DATA_DIFF,
validation_info=None,
validate=False,
save=True)
draft = review_request.get_draft()
draft.target_people = [review_request.submitter]
draft.publish()
review_request = ReviewRequest.objects.get(pk=review_request.pk)
self.assertEqual(review_request.status,
ReviewRequest.PENDING_REVIEW)
def test_history_no_commit_filter(self):
"""Testing the GET <URL> API for a diffset with commits only returns
cumulative files
"""
with override_feature_check(dvcs_feature.feature_id, enabled=True):
repository = self.create_repository()
review_request = self.create_review_request(
repository=repository,
submitter=self.user,
create_with_history=True)
diffset = self.create_diffset(review_request=review_request,
repository=repository)
commit = self.create_diffcommit(diffset=diffset,
repository=repository)
diffset.finalize_commit_series(
cumulative_diff=self.DEFAULT_GIT_FILEDIFF_DATA_DIFF,
validation_info=None,
validate=False,
save=True)
cumulative_filediff = diffset.cumulative_files[0]
rsp = self.api_get(
get_filediff_list_url(diffset, review_request),
expected_mimetype=filediff_list_mimetype)
self.assertIn('stat', rsp)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('files', rsp)
self.assertEqual(rsp['total_results'], 1)
self.assertEqual(rsp['files'][0]['id'],
cumulative_filediff.pk)
self.assertNotEqual(commit.files.get().pk,
cumulative_filediff.pk)