def test_post_too_large(self):
"""Testing the POST <URL> API with a diff that is too large"""
siteconfig = SiteConfiguration.objects.get_current()
max_diff_size = siteconfig.get('diffviewer_max_diff_size')
siteconfig.set('diffviewer_max_diff_size', 1)
siteconfig.save()
repository = self.create_repository(tool_name='Git')
review_request = self.create_review_request(
repository=repository,
submitter=self.user,
create_with_history=True)
diffset = self.create_diffset(review_request, draft=True)
diff = SimpleUploadedFile('diff',
self._DEFAULT_DIFF_CONTENTS,
content_type='text/x-patch')
try:
with override_feature_checks(self.override_features):
rsp = self.api_post(
get_draft_diffcommit_list_url(review_request,
diffset.revision),
dict(self._DEFAULT_POST_DATA, **{
'diff': diff,
}),
expected_status=400)
finally:
siteconfig.set('diffviewer_max_diff_size', max_diff_size)
siteconfig.save()
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], DIFF_TOO_BIG.code)
self.assertEqual(rsp['max_size'], 1)
def test_post_no_history_allowed(self):
"""Testing the POST <URL> API for a review request created without
history support
"""
repository = self.create_repository(tool_name='Git')
review_request = self.create_review_request(
repository=repository,
submitter=self.user,
create_with_history=False)
ReviewRequestDraft.create(review_request)
diffset = self.create_diffset(review_request, draft=True)
diff = SimpleUploadedFile('diff',
self._DEFAULT_DIFF_CONTENTS,
content_type='text/x-patch')
with override_feature_checks(self.override_features):
rsp = self.api_post(
get_draft_diffcommit_list_url(review_request,
diffset.revision),
dict(self._DEFAULT_POST_DATA, **{
'diff': diff,
}),
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_ATTRIBUTE.code)
self.assertEqual(
rsp['reason'],
'This review request was not created with support for multiple '
'commits.\n\n'
'Use the draft_diff resource to upload diffs instead. See the '
'draft_diff link on the parent resource for the URL.')
def test_get_patch_private_repository(self):
"""Testing the GET <URL> API with Accept: text/x-patch on a private
repository
"""
doc = User.objects.get(username='******')
repository = self.create_repository(tool_name='Git', public=False)
repository.users = [doc]
review_request = self.create_review_request(repository=repository,
submitter=doc)
diffset = self.create_diffset(review_request)
commit = self.create_diffcommit(diffset=diffset, repository=repository)
self.client.login(username='******', password='******')
with override_feature_checks(self.override_features):
rsp = self.api_get(
get_diffcommit_item_url(review_request, diffset.revision,
commit.commit_id),
expected_mimetype='text/x-patch',
expected_json=False,
HTTP_ACCEPT='text/x-patch')
self.assertEqual(self.DEFAULT_GIT_FILEDIFF_DATA_DIFF, rsp)
def test_post_with_extra_data_simple(self):
"""Testing the POST <URL> API with extra_data.key=value"""
self.load_fixtures(self.basic_post_fixtures)
if self.basic_post_use_admin:
self._login_user(admin=True)
extra_fields = {
'extra_data.foo': 123,
'extra_data.bar': 456,
'extra_data.baz': '',
'ignored': 'foo',
}
url, mimetype, data, objs = \
self.setup_basic_post_test(self.user, False, None, True)
data.update(extra_fields)
with override_feature_checks(self.override_features):
rsp = self.api_post(url, data, expected_mimetype=mimetype)
self.assertEqual(rsp['stat'], 'ok')
item_rsp = rsp[self.resource.item_result_key]
obj = self.resource.model.objects.get(pk=item_rsp['id'])
self.assertIn('foo', obj.extra_data)
self.assertIn('bar', obj.extra_data)
self.assertNotIn('baz', obj.extra_data)
self.assertNotIn('ignored', obj.extra_data)
self.assertEqual(obj.extra_data['foo'], extra_fields['extra_data.foo'])
self.assertEqual(obj.extra_data['bar'], extra_fields['extra_data.bar'])
def test_post_no_history_allowed(self):
"""Testing the POST <URL> API for a review request created without
history support
"""
repository = self.create_repository(tool_name='Git')
review_request = self.create_review_request(repository=repository,
submitter=self.user,
create_with_history=False)
ReviewRequestDraft.create(review_request)
diffset = self.create_diffset(review_request, draft=True)
diff = SimpleUploadedFile('diff',
self._DEFAULT_DIFF_CONTENTS,
content_type='text/x-patch')
with override_feature_checks(self.override_features):
rsp = self.api_post(get_draft_diffcommit_list_url(
review_request, diffset.revision),
dict(self._DEFAULT_POST_DATA, **{
'diff': diff,
}),
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_ATTRIBUTE.code)
self.assertEqual(
rsp['reason'],
'This review request was not created with support for multiple '
'commits.\n\n'
'Use the draft_diff resource to upload diffs instead. See the '
'draft_diff link on the parent resource for the URL.')
def test_put_with_extra_data_json_with_private_keys(self):
"""Testing the PUT <URL> API with extra_data:json with private keys"""
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_put_use_admin:
self._login_user(admin=True)
url, mimetype, data, obj, objs = \
self.setup_basic_put_test(self.user, False, None, True)
data['extra_data:json'] = json.dumps({
'foo': {
'__bar': {
'num': 123,
'string': 'hi!',
'bool': True,
},
'baz': 456,
},
})
with override_feature_checks(self.override_features):
rsp = self.api_put(url, data, expected_mimetype=mimetype)
self.assertEqual(rsp['stat'], 'ok')
item_rsp = rsp[self.resource.item_result_key]
obj = self.resource.model.objects.get(pk=item_rsp['id'])
self.assertIn('foo', obj.extra_data)
self.assertEqual(obj.extra_data['foo'], {
'baz': 456,
})
def test_put_with_private_extra_data_in_simple_form(self):
"""Testing the PUT <URL> API with private extra_data.__key=value"""
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_put_use_admin:
self._login_user(admin=True)
extra_fields = {
'extra_data.__private_key': 'private_data',
}
url, mimetype, data, obj, objs = \
self.setup_basic_put_test(self.user, False, None, True)
data.update(extra_fields)
with override_feature_checks(self.override_features):
rsp = self.api_put(url, data, expected_mimetype=mimetype)
self.assertEqual(rsp['stat'], 'ok')
item_rsp = rsp[self.resource.item_result_key]
obj = self.resource.model.objects.get(pk=item_rsp['id'])
self.assertNotIn('__private_key', obj.extra_data)
def test_put_with_private_extra_data_in_simple_form(self):
"""Testing the PUT <URL> API with private extra_data.__key=value"""
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_put_use_admin:
self._login_user(admin=True)
extra_fields = {
'extra_data.__private_key': 'private_data',
}
url, mimetype, data, obj, objs = \
self.setup_basic_put_test(self.user, False, None, True)
data.update(extra_fields)
with override_feature_checks(self.override_features):
rsp = self.api_put(url, data, expected_mimetype=mimetype)
self.assertEqual(rsp['stat'], 'ok')
item_rsp = rsp[self.resource.item_result_key]
obj = self.resource.model.objects.get(pk=item_rsp['id'])
self.assertNotIn('__private_key', obj.extra_data)
def test_put_with_extra_data_json_with_private_keys(self):
"""Testing the PUT <URL> API with extra_data:json with private keys"""
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_put_use_admin:
self._login_user(admin=True)
url, mimetype, data, obj, objs = \
self.setup_basic_put_test(self.user, False, None, True)
data['extra_data:json'] = json.dumps({
'foo': {
'__bar': {
'num': 123,
'string': 'hi!',
'bool': True,
},
'baz': 456,
},
})
with override_feature_checks(self.override_features):
rsp = self.api_put(url, data, expected_mimetype=mimetype)
self.assertEqual(rsp['stat'], 'ok')
item_rsp = rsp[self.resource.item_result_key]
obj = self.resource.model.objects.get(pk=item_rsp['id'])
self.assertIn('foo', obj.extra_data)
self.assertEqual(obj.extra_data['foo'], {
'baz': 456,
})
def test_post_with_extra_data_simple(self):
"""Testing the POST <URL> API with extra_data.key=value"""
self.load_fixtures(self.basic_post_fixtures)
if self.basic_post_use_admin:
self._login_user(admin=True)
extra_fields = {
'extra_data.foo': 123,
'extra_data.bar': 456,
'extra_data.baz': '',
'ignored': 'foo',
}
url, mimetype, data, objs = \
self.setup_basic_post_test(self.user, False, None, True)
data.update(extra_fields)
with override_feature_checks(self.override_features):
rsp = self.api_post(url, data, expected_mimetype=mimetype)
self.assertEqual(rsp['stat'], 'ok')
item_rsp = rsp[self.resource.item_result_key]
obj = self.resource.model.objects.get(pk=item_rsp['id'])
self.assertIn('foo', obj.extra_data)
self.assertIn('bar', obj.extra_data)
self.assertNotIn('baz', obj.extra_data)
self.assertNotIn('ignored', obj.extra_data)
self.assertEqual(obj.extra_data['foo'], extra_fields['extra_data.foo'])
self.assertEqual(obj.extra_data['bar'], extra_fields['extra_data.bar'])
def test_get_patch_private_repository(self):
"""Testing the GET <URL> API with Accept: text/x-patch on a private
repository
"""
doc = User.objects.get(username='******')
repository = self.create_repository(tool_name='Git', public=False)
repository.users = [doc]
review_request = self.create_review_request(repository=repository,
submitter=doc)
diffset = self.create_diffset(review_request)
commit = self.create_diffcommit(diffset=diffset, repository=repository)
self.client.login(username='******', password='******')
with override_feature_checks(self.override_features):
rsp = self.api_get(
get_diffcommit_item_url(review_request, diffset.revision,
commit.commit_id),
expected_mimetype='text/x-patch',
expected_json=False,
HTTP_ACCEPT='text/x-patch')
self.assertEqual(self.DEFAULT_GIT_FILEDIFF_DATA, rsp)
def test_get_with_private_extra_data_in_key_form(self):
"""Testing the GET <URL> API with private extra_data in __key form"""
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_get_use_admin:
self._login_user(admin=True)
extra_fields = {
'__private_key': 'private_data',
'public_key': {
'__another_private_key': 'foo',
'another_public_key': 'bar',
},
}
url, mimetype, item = self.setup_basic_get_test(self.user, False, None)
obj = self.resource.model.objects.get(pk=item.id)
obj.extra_data = extra_fields
obj.save(update_fields=['extra_data'])
with override_feature_checks(self.override_features):
rsp = self.api_get(url,
expected_mimetype=mimetype,
expected_json=self.basic_get_returns_json)
item_rsp = rsp[self.resource.item_result_key]
self.assertNotIn('__private_key', item_rsp['extra_data'])
self.assertNotIn('__another_private_key',
item_rsp['extra_data']['public_key'])
self.assertIn('another_public_key',
item_rsp['extra_data']['public_key'])
def test_post_with_extra_fields(self):
"""Testing the POST <URL> API with extra fields"""
self.load_fixtures(self.basic_post_fixtures)
if self.basic_post_use_admin:
self._login_user(admin=True)
extra_fields = {"extra_data.foo": 123, "extra_data.bar": 456, "extra_data.baz": "", "ignored": "foo"}
url, mimetype, data, objs = self.setup_basic_post_test(self.user, False, None, True)
data.update(extra_fields)
with override_feature_checks(self.override_features):
rsp = self.api_post(url, data, expected_mimetype=mimetype)
self.assertEqual(rsp["stat"], "ok")
item_rsp = rsp[self.resource.item_result_key]
obj = self.resource.model.objects.get(pk=item_rsp["id"])
self.assertIn("foo", obj.extra_data)
self.assertIn("bar", obj.extra_data)
self.assertNotIn("baz", obj.extra_data)
self.assertNotIn("ignored", obj.extra_data)
self.assertEqual(obj.extra_data["foo"], extra_fields["extra_data.foo"])
self.assertEqual(obj.extra_data["bar"], extra_fields["extra_data.bar"])
def test_post_too_large(self):
"""Testing the POST <URL> API with a diff that is too large"""
siteconfig = SiteConfiguration.objects.get_current()
max_diff_size = siteconfig.get('diffviewer_max_diff_size')
siteconfig.set('diffviewer_max_diff_size', 1)
siteconfig.save()
repository = self.create_repository(tool_name='Git')
review_request = self.create_review_request(repository=repository,
submitter=self.user,
create_with_history=True)
diffset = self.create_diffset(review_request, draft=True)
diff = SimpleUploadedFile('diff',
self._DEFAULT_DIFF_CONTENTS,
content_type='text/x-patch')
try:
with override_feature_checks(self.override_features):
rsp = self.api_post(get_draft_diffcommit_list_url(
review_request, diffset.revision),
dict(self._DEFAULT_POST_DATA, **{
'diff': diff,
}),
expected_status=400)
finally:
siteconfig.set('diffviewer_max_diff_size', max_diff_size)
siteconfig.save()
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], DIFF_TOO_BIG.code)
self.assertEqual(rsp['max_size'], 1)
def test_get_with_private_extra_fields(self):
"""Testing the GET <URL> API with extra fields"""
self.load_fixtures(getattr(self, "basic_put_fixtures", []))
if self.basic_get_use_admin:
self._login_user(admin=True)
extra_fields = {
"__private_key": "private_data",
"public_key": {"__another_private_key": "foo", "another_public_key": "bar"},
}
url, mimetype, item = self.setup_basic_get_test(self.user, False, None)
obj = self.resource.model.objects.get(pk=item.id)
obj.extra_data = extra_fields
obj.save(update_fields=["extra_data"])
with override_feature_checks(self.override_features):
rsp = self.api_get(url, expected_mimetype=mimetype, expected_json=self.basic_get_returns_json)
item_rsp = rsp[self.resource.item_result_key]
self.assertNotIn("__private_key", item_rsp["extra_data"])
self.assertNotIn("__another_private_key", item_rsp["extra_data"]["public_key"])
self.assertIn("another_public_key", item_rsp["extra_data"]["public_key"])
def test_get_with_private_extra_data_in_key_form(self):
"""Testing the GET <URL> API with private extra_data in __key form"""
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_get_use_admin:
self._login_user(admin=True)
extra_fields = {
'__private_key': 'private_data',
'public_key': {
'__another_private_key': 'foo',
'another_public_key': 'bar',
},
}
url, mimetype, item = self.setup_basic_get_test(self.user, False, None)
obj = self.resource.model.objects.get(pk=item.id)
obj.extra_data = extra_fields
obj.save(update_fields=['extra_data'])
with override_feature_checks(self.override_features):
rsp = self.api_get(url,
expected_mimetype=mimetype,
expected_json=self.basic_get_returns_json)
item_rsp = rsp[self.resource.item_result_key]
self.assertNotIn('__private_key', item_rsp['extra_data'])
self.assertNotIn('__another_private_key',
item_rsp['extra_data']['public_key'])
self.assertIn('another_public_key',
item_rsp['extra_data']['public_key'])
def test_post_repo_no_history_support(self):
"""Testing the POST <URL> API with a repository that does not support
history
"""
repo = self.create_repository(tool_name='Test')
with override_feature_checks(self.override_features):
rsp = self.api_post(get_validate_diffcommit_url(), {
'commit_id':
'r1',
'parent_id':
'r0',
'diff':
SimpleUploadedFile('diff',
self.DEFAULT_GIT_FILEDIFF_DATA,
content_type='text/x-patch'),
'repository':
repo.name,
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_ATTRIBUTE.code)
self.assertEqual(
rsp['reason'],
'The "%s" repository does not support review requests created '
'with history.' % repo.name)
def test_post_diff_too_big(self):
"""Testing the POST <URL> API with a diff that is too big"""
repo = self.create_repository(tool_name='Git')
siteconfig = SiteConfiguration.objects.get_current()
max_diff_size = siteconfig.get('diffviewer_max_diff_size')
siteconfig.set('diffviewer_max_diff_size', 1)
siteconfig.save()
try:
with override_feature_checks(self.override_features):
rsp = self.api_post(get_validate_diffcommit_url(), {
'commit_id':
'r1',
'parent_id':
'r0',
'diff':
SimpleUploadedFile('diff',
self.DEFAULT_GIT_FILEDIFF_DATA,
content_type='text/x-patch'),
'repository':
repo.name,
},
expected_status=400)
finally:
siteconfig.set('diffviewer_max_diff_size', max_diff_size)
siteconfig.save()
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], DIFF_TOO_BIG.code)
self.assertEqual(rsp['max_size'], 1)
def test_post_repo_multiple(self):
"""Testing the POST <URL> API with multiple matching repositories"""
repo = self.create_repository(name='repo')
self.create_repository(name=repo.name)
with override_feature_checks(self.override_features):
rsp = self.api_post(get_validate_diffcommit_url(), {
'commit_id':
'r1',
'parent_id':
'r0',
'diff':
SimpleUploadedFile('diff',
self.DEFAULT_GIT_FILEDIFF_DATA,
content_type='text/x-patch'),
'repository':
repo.name,
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_REPOSITORY.code)
self.assertEqual(
rsp['err']['msg'],
'Too many repositories matched "%s". Try specifying '
'the repository by name instead.' % repo.name)
def test_put_with_extra_data_json_patch_with_private_access_level(self):
"""Testing the PUT <URL> API with extra_data:json-patch with private
access level
"""
def _access_cb(path):
if path == ('a',):
return ExtraDataAccessLevel.ACCESS_STATE_PRIVATE
return ExtraDataAccessLevel.ACCESS_STATE_PUBLIC
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_put_use_admin:
self._login_user(admin=True)
url, mimetype, data, obj, objs = \
self.setup_basic_put_test(self.user, False, None, True)
obj.extra_data = {
'a': 1,
}
obj.save()
try:
self.resource.extra_data_access_callbacks.register(_access_cb)
data['extra_data:json-patch'] = json.dumps([
{
'op': 'add',
'path': '/b',
'value': 1,
},
{
'op': 'remove',
'path': '/a',
},
])
with override_feature_checks(self.override_features):
rsp = self.api_put(url, data, expected_status=400)
finally:
self.resource.extra_data_access_callbacks.unregister(_access_cb)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err'], {
'code': INVALID_FORM_DATA.code,
'msg': 'One or more fields had errors',
})
self.assertEqual(rsp['fields'], {
'extra_data': [
'Failed to patch JSON data: Cannot write to path "/a" '
'for patch entry 1',
],
})
obj = self.resource.model.objects.get(pk=obj.pk)
self.assertEqual(obj.extra_data, {
'a': 1,
})
def test_delete_with_site(self):
"""Testing the DELETE <URL> API with access to a local site"""
user, url, cb_args = self._setup_test_delete_with_site()
with override_feature_checks(self.override_features):
self.api_delete(url)
self.check_delete_result(user, *cb_args)
def test_delete_with_site(self):
"""Testing the DELETE <URL> API with access to a local site"""
user, url, cb_args = self._setup_test_delete_with_site()
with override_feature_checks(self.override_features):
self.api_delete(url)
self.check_delete_result(user, *cb_args)
def test_post_subsequent(self):
"""Testing the POST <URL> API with a subsequent commit"""
repository = self.create_repository(tool_name='Git')
review_request = self.create_review_request(
repository=repository,
submitter=self.user,
create_with_history=True)
diffset = self.create_diffset(review_request, draft=True)
commit = self.create_diffcommit(
repository,
diffset,
diff_contents=self._DEFAULT_DIFF_CONTENTS)
validation_info = serialize_validation_info({
commit.commit_id: {
'parent_id': commit.parent_id,
'tree': {
'added': [],
'modified': [{
'filename': 'readme',
'revision': '5b50866',
}],
'removed': [],
},
},
})
diff = SimpleUploadedFile(
'diff',
(b'diff --git a/readme b/readme\n'
b'index 5b50866..f00f00f 100644\n'
b'--- a/readme\n'
b'+++ a/readme\n'
b'@@ -1 +1,4 @@\n'
b' Hello there\n'
b' \n'
b' Oh hi!\n'
b'+Goodbye!\n'),
content_type='text/x-patch')
with override_feature_checks(self.override_features):
rsp = self.api_post(
get_draft_diffcommit_list_url(review_request,
diffset.revision),
dict(self._DEFAULT_POST_DATA, **{
'commit_id': 'r2',
'parent_id': 'r1',
'diff': diff,
'validation_info': validation_info,
}),
expected_mimetype=draft_diffcommit_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('draft_commit', rsp)
item_rsp = rsp['draft_commit']
self.compare_item(item_rsp, DiffCommit.objects.get(pk=item_rsp['id']))
def test_post_parent_diff_subsequent(self):
"""Testing the POST <URL> API with a parent diff on a subsequent commit
"""
parent_diff_contents = (
b'diff --git a/foo b/foo\n'
b'new file mode 100644\n'
b'index 0000000..e69de29\n'
)
diff_contents = (
b'diff --git a/foo b/foo\n'
b'index e69ded29..03b37a0 100644\n'
b'--- a/foo\n'
b'+++ b/foo\n'
b'@@ -0,0 +1 @@'
b'+foo bar baz qux\n'
)
repository = self.create_repository(tool_name='Git')
review_request = self.create_review_request(
repository=repository,
submitter=self.user,
create_with_history=True)
diffset = self.create_diffset(review_request, draft=True)
self.create_diffcommit(repository, diffset)
diff = SimpleUploadedFile('diff', diff_contents,
content_type='text/x-patch')
parent_diff = SimpleUploadedFile('parent_diff', parent_diff_contents,
content_type='text/x-patch')
with override_feature_checks(self.override_features):
rsp = self.api_post(
get_draft_diffcommit_list_url(review_request,
diffset.revision),
dict(self._DEFAULT_POST_DATA, **{
'commit_id': 'r0',
'parent_id': 'r1',
'diff': diff,
'parent_diff': parent_diff,
}),
expected_mimetype=draft_diffcommit_item_mimetype,
expected_status=201)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('draft_commit', rsp)
item_rsp = rsp['draft_commit']
commit = DiffCommit.objects.get(pk=item_rsp['id'])
self.compare_item(item_rsp, commit)
files = list(commit.files.all())
self.assertEqual(len(files), 1)
f = files[0]
self.assertIsNotNone(f.parent_diff)
def test_post_parent_diff_subsequent(self):
"""Testing the POST <URL> API with a parent diff on a subsequent commit
"""
parent_diff_contents = (b'diff --git a/foo b/foo\n'
b'new file mode 100644\n'
b'index 0000000..e69de29\n')
diff_contents = (b'diff --git a/foo b/foo\n'
b'index e69ded29..03b37a0 100644\n'
b'--- a/foo\n'
b'+++ b/foo\n'
b'@@ -0,0 +1 @@'
b'+foo bar baz qux\n')
repository = self.create_repository(tool_name='Git')
review_request = self.create_review_request(repository=repository,
submitter=self.user,
create_with_history=True)
diffset = self.create_diffset(review_request, draft=True)
self.create_diffcommit(repository, diffset)
diff = SimpleUploadedFile('diff',
diff_contents,
content_type='text/x-patch')
parent_diff = SimpleUploadedFile('parent_diff',
parent_diff_contents,
content_type='text/x-patch')
with override_feature_checks(self.override_features):
rsp = self.api_post(
get_draft_diffcommit_list_url(review_request,
diffset.revision),
dict(
self._DEFAULT_POST_DATA, **{
'commit_id': 'r0',
'parent_id': 'r1',
'diff': diff,
'parent_diff': parent_diff,
}),
expected_mimetype=draft_diffcommit_item_mimetype,
expected_status=201)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('draft_commit', rsp)
item_rsp = rsp['draft_commit']
commit = DiffCommit.objects.get(pk=item_rsp['id'])
self.compare_item(item_rsp, commit)
files = list(commit.files.all())
self.assertEqual(len(files), 1)
f = files[0]
self.assertIsNotNone(f.parent_diff)
def test_post_subsequent(self):
"""Testing the POST <URL> API with a subsequent commit"""
repository = self.create_repository(tool_name='Git')
review_request = self.create_review_request(repository=repository,
submitter=self.user,
create_with_history=True)
diffset = self.create_diffset(review_request, draft=True)
commit = self.create_diffcommit(
repository, diffset, diff_contents=self._DEFAULT_DIFF_CONTENTS)
validation_info = \
resources.validate_diffcommit.serialize_validation_info({
commit.commit_id: {
'parent_id': commit.parent_id,
'tree': {
'added': [],
'modified': [{
'filename': 'readme',
'revision': '5b50866',
}],
'removed': [],
},
},
})
diff = SimpleUploadedFile('diff', (b'diff --git a/readme b/readme\n'
b'index 5b50866..f00f00f 100644\n'
b'--- a/readme\n'
b'+++ a/readme\n'
b'@@ -1 +1,4 @@\n'
b' Hello there\n'
b' \n'
b' Oh hi!\n'
b'+Goodbye!\n'),
content_type='text/x-patch')
with override_feature_checks(self.override_features):
rsp = self.api_post(
get_draft_diffcommit_list_url(review_request,
diffset.revision),
dict(
self._DEFAULT_POST_DATA, **{
'commit_id': 'r2',
'parent_id': 'r1',
'diff': diff,
'validation_info': validation_info,
}),
expected_mimetype=draft_diffcommit_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn('draft_commit', rsp)
item_rsp = rsp['draft_commit']
self.compare_item(item_rsp, DiffCommit.objects.get(pk=item_rsp['id']))
def test_get_with_site_no_access(self):
"""Testing the GET <URL> API without access to a local site"""
user, url, mimetype, item = self._setup_test_get_with_site()
self._login_user()
with override_feature_checks(self.override_features):
rsp = self.api_get(url, expected_status=403)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)
def test_post_with_site(self):
"""Testing the POST <URL> API with access to a local site"""
user, url, mimetype, post_data, cb_args = \
self._setup_test_post_with_site()
with override_feature_checks(self.override_features):
rsp = self.api_post(url, post_data, expected_mimetype=mimetype)
self._close_file_handles(post_data)
self.assertEqual(rsp['stat'], 'ok')
self.check_post_result(user, rsp, *cb_args)
def test_get_not_modified(self):
"""Testing the GET <URL> API
with Not Modified response
"""
review_request = self.create_review_request(publish=True)
status_update = self.create_status_update(review_request)
with override_feature_checks(self.override_features):
self._testHttpCaching(get_status_update_item_url(
review_request, status_update.pk),
check_etags=True)
def test_post_with_site(self):
"""Testing the POST <URL> API with access to a local site"""
user, url, mimetype, post_data, cb_args = \
self._setup_test_post_with_site()
with override_feature_checks(self.override_features):
rsp = self.api_post(url, post_data, expected_mimetype=mimetype)
self._close_file_handles(post_data)
self.assertEqual(rsp['stat'], 'ok')
self.check_post_result(user, rsp, *cb_args)
def fetch_resource_data(self, resource, mimetype):
features = {feature.feature_id: True for feature in resource.required_features}
with override_feature_checks(features):
kwargs = {}
request = DummyRequest()
request.path = create_fake_resource_path(request, resource, kwargs, "is-list" not in self.options)
headers, data = fetch_response_data(resource, mimetype, request, **kwargs)
return request.path, headers, data
def test_get_with_site_no_access(self):
"""Testing the GET <URL> API without access to a local site"""
user, url, mimetype, item = self._setup_test_get_with_site()
self._login_user()
with override_feature_checks(self.override_features):
rsp = self.api_get(url, expected_status=403)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)
def test_get_not_modified(self):
"""Testing the GET <URL> API
with Not Modified response
"""
review_request = self.create_review_request(publish=True)
status_update = self.create_status_update(review_request)
with override_feature_checks(self.override_features):
self._testHttpCaching(
get_status_update_item_url(review_request, status_update.pk),
check_etags=True)
def test_delete(self):
"""Testing the DELETE <URL> API"""
self.load_fixtures(self.basic_delete_fixtures)
self._login_user(admin=self.basic_delete_use_admin)
url, cb_args = self.setup_basic_delete_test(self.user, False, None)
self.assertFalse(url.startswith('/s/' + self.local_site_name))
with override_feature_checks(self.override_features):
self.api_delete(url)
self.check_delete_result(self.user, *cb_args)
def test_delete_with_restrict_site_and_allowed(self):
"""Testing the DELETE <URL> API with access to a local site
and session restricted to the site
"""
user, url, cb_args = self._setup_test_delete_with_site(
with_webapi_token=True,
webapi_token_local_site_id=self.local_site_id)
with override_feature_checks(self.override_features):
self.api_delete(url)
self.check_delete_result(user, *cb_args)
def test_delete(self):
"""Testing the DELETE <URL> API"""
self.load_fixtures(self.basic_delete_fixtures)
self._login_user(admin=self.basic_delete_use_admin)
url, cb_args = self.setup_basic_delete_test(self.user, False, None)
self.assertFalse(url.startswith('/s/' + self.local_site_name))
with override_feature_checks(self.override_features):
self.api_delete(url)
self.check_delete_result(self.user, *cb_args)
def test_put_with_extra_data_json_patch(self):
"""Testing the PUT <URL> API with extra_data:json-patch"""
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_put_use_admin:
self._login_user(admin=True)
url, mimetype, data, obj, objs = \
self.setup_basic_put_test(self.user, False, None, True)
obj.extra_data = {
'a': 1,
'b': {
'c': 2,
},
}
obj.save()
data = {
'extra_data:json-patch':
json.dumps([
{
'op': 'add',
'path': '/b/d',
'value': 3,
},
{
'op': 'remove',
'path': '/a',
},
{
'op': 'copy',
'from': '/b/c',
'path': '/e',
},
]),
}
with override_feature_checks(self.override_features):
rsp = self.api_put(url, data, expected_mimetype=mimetype)
self.assertEqual(rsp['stat'], 'ok')
item_rsp = rsp[self.resource.item_result_key]
obj = self.resource.model.objects.get(pk=item_rsp['id'])
self.assertEqual(obj.extra_data, {
'b': {
'c': 2,
'd': 3,
},
'e': 2,
})
def test_delete_with_restrict_site_and_allowed(self):
"""Testing the DELETE <URL> API with access to a local site
and session restricted to the site
"""
user, url, cb_args = self._setup_test_delete_with_site(
with_webapi_token=True,
webapi_token_local_site_id=self.local_site_id)
with override_feature_checks(self.override_features):
self.api_delete(url)
self.check_delete_result(user, *cb_args)
def test_put_with_extra_data_json_patch(self):
"""Testing the PUT <URL> API with extra_data:json-patch"""
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_put_use_admin:
self._login_user(admin=True)
url, mimetype, data, obj, objs = \
self.setup_basic_put_test(self.user, False, None, True)
obj.extra_data = {
'a': 1,
'b': {
'c': 2,
},
}
obj.save()
data = {
'extra_data:json-patch': json.dumps([
{
'op': 'add',
'path': '/b/d',
'value': 3,
},
{
'op': 'remove',
'path': '/a',
},
{
'op': 'copy',
'from': '/b/c',
'path': '/e',
},
]),
}
with override_feature_checks(self.override_features):
rsp = self.api_put(url, data, expected_mimetype=mimetype)
self.assertEqual(rsp['stat'], 'ok')
item_rsp = rsp[self.resource.item_result_key]
obj = self.resource.model.objects.get(pk=item_rsp['id'])
self.assertEqual(obj.extra_data, {
'b': {
'c': 2,
'd': 3,
},
'e': 2,
})
def test_put_with_extra_data_json_with_access_levels(self):
"""Testing the PUT <URL> API with extra_data:json with access levels"""
def _access_cb(path):
if path == ('parent', 'private'):
return ExtraDataAccessLevel.ACCESS_STATE_PRIVATE
elif path == ('public-readonly', ):
return ExtraDataAccessLevel.ACCESS_STATE_PUBLIC_READONLY
else:
return ExtraDataAccessLevel.ACCESS_STATE_PUBLIC
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_put_use_admin:
self._login_user(admin=True)
url, mimetype, data, obj, objs = \
self.setup_basic_put_test(self.user, False, None, True)
obj.extra_data = {
'public-readonly': 'orig',
}
obj.save()
try:
self.resource.extra_data_access_callbacks.register(_access_cb)
data = {
'extra_data:json':
json.dumps({
'parent': {
'private': 1,
},
'public-readonly': 2,
'test': 3,
})
}
with override_feature_checks(self.override_features):
rsp = self.api_put(url, data, expected_mimetype=mimetype)
finally:
self.resource.extra_data_access_callbacks.unregister(_access_cb)
self.assertEqual(rsp['stat'], 'ok')
item_rsp = rsp[self.resource.item_result_key]
obj = self.resource.model.objects.get(pk=item_rsp['id'])
self.assertEqual(obj.extra_data, {
'parent': {},
'public-readonly': 'orig',
'test': 3,
})
def test_post_with_site_no_access(self):
"""Testing the POST <URL> API without access to a local site"""
user, url, mimetype, post_data, cb_args = \
self._setup_test_post_with_site()
self._login_user()
with override_feature_checks(self.override_features):
rsp = self.api_post(url, post_data, expected_status=403)
self._close_file_handles(post_data)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)
def test_get_with_restrict_site_and_not_allowed(self):
"""Testing the GET <URL> API with access to a local site
and session restricted to a different site
"""
user, url, mimetype, items = self._setup_test_get_list_with_site(
with_webapi_token=True,
webapi_token_local_site_id=self.local_site_id + 1)
with override_feature_checks(self.override_features):
rsp = self.api_get(url, expected_status=403)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)
def test_post_with_site_no_access(self):
"""Testing the POST <URL> API without access to a local site"""
user, url, mimetype, post_data, cb_args = \
self._setup_test_post_with_site()
self._login_user()
with override_feature_checks(self.override_features):
rsp = self.api_post(url, post_data, expected_status=403)
self._close_file_handles(post_data)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)
def test_put_with_site(self):
"""Testing the PUT <URL> API with access to a local site"""
user, url, mimetype, put_data, item, cb_args = \
self._setup_test_put_with_site()
with override_feature_checks(self.override_features):
rsp = self.api_put(url, put_data, expected_mimetype=mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn(self.resource.item_result_key, rsp)
self.check_put_result(user, rsp[self.resource.item_result_key],
item, *cb_args)
def test_get_patch(self):
"""Testing the GET <URL> API with Accept: text/x-patch"""
url = self.setup_basic_get_test(self.user,
with_local_site=False,
local_site_name=None)[0]
with override_feature_checks(self.override_features):
rsp = self.api_get(url,
expected_mimetype='text/x-patch',
expected_json=False,
HTTP_ACCEPT='text/x-patch')
self.assertEqual(self.DEFAULT_GIT_FILEDIFF_DATA_DIFF, rsp)
def test_delete_with_does_not_exist(self):
"""Testing the DELETE <URL> API
with Does Not Exist error
"""
review_request = self.create_review_request(publish=True)
with override_feature_checks(self.override_features):
rsp = self.api_delete(get_status_update_item_url(
review_request, 12345),
expected_status=404)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], DOES_NOT_EXIST.code)
def test_get_patch(self):
"""Testing the GET <URL> API with Accept: text/x-patch"""
url = self.setup_basic_get_test(self.user,
with_local_site=False,
local_site_name=None)[0]
with override_feature_checks(self.override_features):
rsp = self.api_get(url,
expected_mimetype='text/x-patch',
expected_json=False,
HTTP_ACCEPT='text/x-patch')
self.assertEqual(self.DEFAULT_GIT_FILEDIFF_DATA, rsp)
def test_put_with_site(self):
"""Testing the PUT <URL> API with access to a local site"""
user, url, mimetype, put_data, item, cb_args = \
self._setup_test_put_with_site()
with override_feature_checks(self.override_features):
rsp = self.api_put(url, put_data, expected_mimetype=mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertIn(self.resource.item_result_key, rsp)
self.check_put_result(user, rsp[self.resource.item_result_key], item,
*cb_args)
def test_delete_with_does_not_exist(self):
"""Testing the DELETE <URL> API
with Does Not Exist error
"""
review_request = self.create_review_request(publish=True)
with override_feature_checks(self.override_features):
rsp = self.api_delete(
get_status_update_item_url(review_request, 12345),
expected_status=404)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], DOES_NOT_EXIST.code)
def test_get_with_restrict_site_and_not_allowed(self):
"""Testing the GET <URL> API with access to a local site
and session restricted to a different site
"""
user, url, mimetype, items = self._setup_test_get_list_with_site(
with_webapi_token=True,
webapi_token_local_site_id=self.local_site_id + 1)
with override_feature_checks(self.override_features):
rsp = self.api_get(url, expected_status=403)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)
def test_put_with_extra_data_json_patch_with_private_keys(self):
"""Testing the PUT <URL> API with extra_data:json-patch with private
keys
"""
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_put_use_admin:
self._login_user(admin=True)
url, mimetype, data, obj, objs = \
self.setup_basic_put_test(self.user, False, None, True)
obj.extra_data = {
'a': 1,
'b': {
'__c': 2,
},
}
obj.save()
data['extra_data:json-patch'] = json.dumps([
{
'op': 'remove',
'path': '/b/__c',
},
])
with override_feature_checks(self.override_features):
rsp = self.api_put(url, data, expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(
rsp['err'], {
'code': INVALID_FORM_DATA.code,
'msg': 'One or more fields had errors',
})
self.assertEqual(
rsp['fields'], {
'extra_data': [
'Failed to patch JSON data: Cannot write to path "/b/__c" '
'for patch entry 0',
],
})
obj = self.resource.model.objects.get(pk=obj.pk)
self.assertEqual(obj.extra_data, {
'a': 1,
'b': {
'__c': 2,
},
})
def test_put_with_extra_data_json_with_access_levels(self):
"""Testing the PUT <URL> API with extra_data:json with access levels"""
def _access_cb(path):
if path == ('parent', 'private'):
return ExtraDataAccessLevel.ACCESS_STATE_PRIVATE
elif path == ('public-readonly',):
return ExtraDataAccessLevel.ACCESS_STATE_PUBLIC_READONLY
else:
return ExtraDataAccessLevel.ACCESS_STATE_PUBLIC
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_put_use_admin:
self._login_user(admin=True)
url, mimetype, data, obj, objs = \
self.setup_basic_put_test(self.user, False, None, True)
obj.extra_data = {
'public-readonly': 'orig',
}
obj.save()
try:
self.resource.extra_data_access_callbacks.register(_access_cb)
data = {
'extra_data:json': json.dumps({
'parent': {
'private': 1,
},
'public-readonly': 2,
'test': 3,
})
}
with override_feature_checks(self.override_features):
rsp = self.api_put(url, data, expected_mimetype=mimetype)
finally:
self.resource.extra_data_access_callbacks.unregister(_access_cb)
self.assertEqual(rsp['stat'], 'ok')
item_rsp = rsp[self.resource.item_result_key]
obj = self.resource.model.objects.get(pk=item_rsp['id'])
self.assertEqual(obj.extra_data, {
'parent': {},
'public-readonly': 'orig',
'test': 3,
})
def test_put_with_extra_data_json_patch_with_private_keys(self):
"""Testing the PUT <URL> API with extra_data:json-patch with private
keys
"""
self.load_fixtures(getattr(self, 'basic_put_fixtures', []))
if self.basic_put_use_admin:
self._login_user(admin=True)
url, mimetype, data, obj, objs = \
self.setup_basic_put_test(self.user, False, None, True)
obj.extra_data = {
'a': 1,
'b': {
'__c': 2,
},
}
obj.save()
data['extra_data:json-patch'] = json.dumps([
{
'op': 'remove',
'path': '/b/__c',
},
])
with override_feature_checks(self.override_features):
rsp = self.api_put(url, data, expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err'], {
'code': INVALID_FORM_DATA.code,
'msg': 'One or more fields had errors',
})
self.assertEqual(rsp['fields'], {
'extra_data': [
'Failed to patch JSON data: Cannot write to path "/b/__c" '
'for patch entry 0',
],
})
obj = self.resource.model.objects.get(pk=obj.pk)
self.assertEqual(obj.extra_data, {
'a': 1,
'b': {
'__c': 2,
},
})
def test_get_with_private_group_no_access(self):
"""Testing the GET <URL> API
without access to review request on a private group
"""
group = self.create_review_group(invite_only=True)
review_request = self.create_review_request(publish=True)
review_request.target_groups.add(group)
url, mimetype = self.setup_review_request_child_test(review_request)
with override_feature_checks(self.override_features):
rsp = self.api_get(url, expected_status=403)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)
def test_get_with_private_repo(self):
"""Testing the GET <URL> API
with access to review request on a private repository
"""
repository = self.create_repository(public=False, tool_name='Test')
repository.users.add(self.user)
review_request = self.create_review_request(repository=repository,
publish=True)
url, mimetype = self.setup_review_request_child_test(review_request)
with override_feature_checks(self.override_features):
self.api_get(url,
expected_mimetype=mimetype,
expected_json=self.basic_get_returns_json)
def test_get_with_private_group_no_access(self):
"""Testing the GET <URL> API
without access to review request on a private group
"""
group = self.create_review_group(invite_only=True)
review_request = self.create_review_request(publish=True)
review_request.target_groups.add(group)
url, mimetype = self.setup_review_request_child_test(review_request)
with override_feature_checks(self.override_features):
rsp = self.api_get(url, expected_status=403)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)
def test_post_with_invalid_review_id(self):
"""Testing the POST <URL> API with an invalid review_id"""
review_request = self.create_review_request(publish=True)
with override_feature_checks(self.override_features):
rsp = self.api_post(get_status_update_list_url(review_request), {
'service_id': 'Service',
'summary': 'Summary',
'review_id': '123456',
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], INVALID_FORM_DATA.code)
self.assertTrue('review_id' in rsp['fields'])
def test_get_with_private_repo(self):
"""Testing the GET <URL> API
with access to review request on a private repository
"""
repository = self.create_repository(public=False, tool_name='Test')
repository.users.add(self.user)
review_request = self.create_review_request(repository=repository,
publish=True)
url, mimetype = self.setup_review_request_child_test(review_request)
with override_feature_checks(self.override_features):
self.api_get(url,
expected_mimetype=mimetype,
expected_json=self.basic_get_returns_json)
def test_get_with_private_repo_no_access(self):
"""Testing the GET <URL> API
without access to review request on a private repository
"""
repository = self.create_repository(public=False, tool_name='Test')
review_request = self.create_review_request(repository=repository,
publish=True)
url, mimetype = self.setup_review_request_child_test(review_request)
with override_feature_checks(self.override_features):
rsp = self.api_get(url, expected_status=403)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)
def test_get_with_private_repo_no_access(self):
"""Testing the GET <URL> API
without access to review request on a private repository
"""
repository = self.create_repository(public=False, tool_name='Test')
review_request = self.create_review_request(repository=repository,
publish=True)
url, mimetype = self.setup_review_request_child_test(review_request)
with override_feature_checks(self.override_features):
rsp = self.api_get(url, expected_status=403)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], PERMISSION_DENIED.code)
