def test_get_or_create_user_auth_backend(self):
"""Testing the PUT review-requests/<id>/draft/ API
with AuthBackend.get_or_create_user failure
"""
class SandboxAuthBackend(AuthBackend):
backend_id = 'test-id'
name = 'test'
def get_or_create_user(self, username, request=None,
password=None):
raise Exception
backend = SandboxAuthBackend()
self.spy_on(auth.get_backends, call_fake=lambda: [backend])
# The first spy messes with permissions, this lets it through
self.spy_on(ReviewRequest.is_mutable_by, call_fake=lambda x, y: True)
self.spy_on(backend.get_or_create_user)
review_request = self.create_review_request(
submitter=self.user)
ReviewRequestDraft.create(review_request)
rsp = self.api_put(
get_review_request_draft_url(review_request, None),
{
'target_people': 'Target',
},
expected_status=400)
self.assertEqual(rsp['stat'], 'fail')
self.assertTrue(backend.get_or_create_user.called)
def test_create_with_existing_new_draft(self):
"""Testing ReviewRequestDraft.create with existing draft"""
review_request = self.create_review_request(
publish=True,
bugs_closed='1,20,300',
commit_id='abc123',
description_rich_text=True,
rich_text=True,
testing_done_rich_text=True,
extra_data={
'key': {
'values': [1, 2, 3],
},
'mybool': True,
})
# Create the first draft.
orig_draft = ReviewRequestDraft.create(review_request)
self.assertIsNotNone(orig_draft.changedesc)
# Try to create it again.
draft = ReviewRequestDraft.create(review_request)
self.assertIsNotNone(draft.changedesc)
self.assertEqual(orig_draft, draft)
self.assertEqual(orig_draft.changedesc, draft.changedesc)
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 setup_basic_delete_test(self, user, with_local_site, local_site_name):
review_request = self.create_review_request(
with_local_site=with_local_site,
submitter=user,
publish=True)
ReviewRequestDraft.create(review_request)
return (get_review_request_draft_url(review_request, local_site_name),
[review_request])
def test_outgoing_requests(self):
"""Testing counters with creating outgoing review requests"""
# The review request was already created
self._check_counters(total_outgoing=1,
pending_outgoing=1)
ReviewRequestDraft.create(self.review_request)
self.review_request.publish(self.user)
self._check_counters(total_outgoing=1,
pending_outgoing=1,
starred_public=1)
def test_put_publish(self):
"""Testing the PUT review-requests/<id>/draft/?public=1 API"""
self.siteconfig.set("mail_send_review_mail", True)
self.siteconfig.save()
review_request = self.create_review_request(submitter=self.user, publish=True)
draft = ReviewRequestDraft.create(review_request)
draft.summary = "My Summary"
draft.description = "My Description"
draft.testing_done = "My Testing Done"
draft.branch = "My Branch"
draft.target_people.add(User.objects.get(username="******"))
draft.save()
mail.outbox = []
rsp = self.apiPut(
get_review_request_draft_url(review_request),
{"public": True},
expected_mimetype=review_request_draft_item_mimetype,
)
self.assertEqual(rsp["stat"], "ok")
review_request = ReviewRequest.objects.get(pk=review_request.id)
self.assertEqual(review_request.summary, "My Summary")
self.assertEqual(review_request.description, "My Description")
self.assertEqual(review_request.testing_done, "My Testing Done")
self.assertEqual(review_request.branch, "My Branch")
self.assertTrue(review_request.public)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, "Re: Review Request %s: My Summary" % review_request.pk)
self.assertValidRecipients(["doc", "grumpy"])
def _test_put_with_text_type_escaping_unspecified_fields(self, text_type, text, expected_text):
self.assertIn(text_type, ("markdown", "plain"))
rich_text = text_type == "markdown"
description = "`This` is the **description**"
review_request = self.create_review_request(submitter=self.user, publish=True)
review_request.rich_text = not rich_text
review_request.description = text
review_request.testing_done = text
review_request.save()
draft = ReviewRequestDraft.create(review_request)
draft.changedesc.text = text
draft.changedesc.save()
rsp = self.api_put(
get_review_request_draft_url(review_request),
{"text_type": text_type, "description": description},
expected_mimetype=review_request_draft_item_mimetype,
)
self.assertEqual(rsp["stat"], "ok")
draft_rsp = rsp["draft"]
self.assertEqual(draft_rsp["text_type"], text_type)
self.assertEqual(draft_rsp["changedescription"], expected_text)
self.assertEqual(draft_rsp["description"], description)
self.assertEqual(draft_rsp["testing_done"], expected_text)
draft = ReviewRequestDraft.objects.get(pk=rsp["draft"]["id"])
self.compare_item(draft_rsp, draft)
def test_put_without_text_type_and_escaping_provided_fields(self):
"""Testing the PUT review-requests/<id>/draft/ API
without changing text_type and with escaping provided fields
"""
review_request = self.create_review_request(submitter=self.user, publish=True)
review_request.rich_text = True
review_request.save()
draft = ReviewRequestDraft.create(review_request)
self.assertTrue(draft.rich_text)
self.assertTrue(draft.changedesc.rich_text)
rsp = self.api_put(
get_review_request_draft_url(review_request),
{
"description": "This is **Description**",
"testing_done": "This is **Testing Done**",
"changedescription": "This is **Change Description**",
},
expected_mimetype=review_request_draft_item_mimetype,
)
self.assertEqual(rsp["stat"], "ok")
draft_rsp = rsp["draft"]
self.assertEqual(draft_rsp["text_type"], "markdown")
self.assertEqual(draft_rsp["description"], "This is \*\*Description\*\*")
self.assertEqual(draft_rsp["testing_done"], "This is \*\*Testing Done\*\*")
self.assertEqual(draft_rsp["changedescription"], "This is \*\*Change Description\*\*")
draft = ReviewRequestDraft.objects.get(pk=rsp["draft"]["id"])
self.compare_item(draft_rsp, draft)
def _test_put_with_rich_text_escaping_unspecified_fields(
self, rich_text, text, expected_text):
description = '`This` is the **description**'
review_request = self.create_review_request(submitter=self.user,
publish=True)
review_request.rich_text = not rich_text
review_request.description = text
review_request.testing_done = text
review_request.save()
draft = ReviewRequestDraft.create(review_request)
draft.changedesc.text = text
draft.changedesc.save()
rsp = self.apiPut(
get_review_request_draft_url(review_request),
{
'rich_text': rich_text,
'description': description,
},
expected_mimetype=review_request_draft_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
draft_rsp = rsp['draft']
self.assertEqual(draft_rsp['rich_text'], rich_text)
self.assertEqual(draft_rsp['changedescription'], expected_text)
self.assertEqual(draft_rsp['description'], description)
self.assertEqual(draft_rsp['testing_done'], expected_text)
draft = ReviewRequestDraft.objects.get(pk=rsp['draft']['id'])
self.compare_item(draft_rsp, draft)
def setUp(self):
super(SandboxTests, self).setUp()
register_ui(InitReviewUI)
register_ui(SandboxReviewUI)
register_ui(ConflictFreeReviewUI)
self.factory = RequestFactory()
filename = os.path.join(settings.STATIC_ROOT,
'rb', 'images', 'trophy.png')
with open(filename, 'r') as f:
self.file = SimpleUploadedFile(f.name, f.read(),
content_type='image/png')
self.user = User.objects.get(username='******')
self.review_request = ReviewRequest.objects.create(self.user, None)
self.file_attachment1 = FileAttachment.objects.create(
mimetype='image/jpg',
file=self.file)
self.file_attachment2 = FileAttachment.objects.create(
mimetype='image/png',
file=self.file)
self.file_attachment3 = FileAttachment.objects.create(
mimetype='image/gif',
file=self.file)
self.review_request.file_attachments.add(self.file_attachment1)
self.review_request.file_attachments.add(self.file_attachment2)
self.review_request.file_attachments.add(self.file_attachment3)
self.draft = ReviewRequestDraft.create(self.review_request)
def create_file_attachment(self, review_request,
orig_filename='filename.png',
caption='My Caption',
draft=False,
**kwargs):
"""Creates a FileAttachment for testing.
The FileAttachment is tied to the given ReviewRequest. It's populated
with default data that can be overridden by the caller.
"""
file_attachment = FileAttachment(
caption=caption,
orig_filename=orig_filename,
mimetype='image/png',
**kwargs)
filename = os.path.join(settings.STATIC_ROOT, 'rb', 'images',
'trophy.png')
with open(filename, 'r') as f:
file_attachment.file.save(filename, File(f), save=True)
if draft:
review_request_draft = ReviewRequestDraft.create(review_request)
review_request_draft.file_attachments.add(file_attachment)
else:
review_request.file_attachments.add(file_attachment)
return file_attachment
def create(self, file, review_request, filediff=None):
caption = self.cleaned_data['caption'] or file.name
if (not file.content_type or
file.content_type == 'application/octet-stream'):
# We can't rely on the browser for the file type here, so
# attempt to guess it.
mimetype = self._guess_mimetype(file)
else:
mimetype = file.content_type
filename = '%s__%s' % (uuid4(), file.name)
attachment_kwargs = {
'caption': '',
'draft_caption': caption,
'orig_filename': os.path.basename(file.name),
'mimetype': mimetype,
}
if filediff:
file_attachment = FileAttachment.objects.create_from_filediff(
filediff,
save=False,
**attachment_kwargs)
else:
file_attachment = FileAttachment(**attachment_kwargs)
file_attachment.file.save(filename, file, save=True)
draft = ReviewRequestDraft.create(review_request)
draft.file_attachments.add(file_attachment)
draft.save()
return file_attachment
def create(self, file, review_request, filediff=None):
caption = self.cleaned_data['caption'] or file.name
mimetype = file.content_type or self._guess_mimetype(file)
filename = '%s__%s' % (uuid4(), file.name)
attachment_kwargs = {
'caption': '',
'draft_caption': caption,
'orig_filename': os.path.basename(file.name),
'mimetype': mimetype,
}
if filediff:
file_attachment = FileAttachment.objects.create_from_filediff(
filediff,
save=False,
**attachment_kwargs)
else:
file_attachment = FileAttachment(**attachment_kwargs)
file_attachment.file.save(filename, file, save=True)
draft = ReviewRequestDraft.create(review_request)
draft.file_attachments.add(file_attachment)
draft.save()
return file_attachment
def test_create_with_site_and_commit_id_conflicts_draft(self):
"""Testing ReviewRequest.objects.create with LocalSite and
commit ID that conflicts with a draft
"""
user = User.objects.get(username='******')
local_site = LocalSite.objects.create(name='test')
repository = self.create_repository()
# This one should be fine.
existing_review_request = ReviewRequest.objects.create(
user, repository, local_site=local_site)
existing_draft = ReviewRequestDraft.create(existing_review_request)
existing_draft.commit_id = '123'
existing_draft.save()
self.assertEqual(local_site.review_requests.count(), 1)
# This one will yell.
with self.assertRaises(ChangeNumberInUseError):
ReviewRequest.objects.create(
user,
repository,
commit_id='123',
local_site=local_site)
# Make sure that entry doesn't exist in the database.
self.assertEqual(local_site.review_requests.count(), 1)
def create_screenshot(self, review_request, caption='My caption',
draft=False, active=True, **kwargs):
"""Create a Screenshot for testing.
The screenshot is tied to the given
:py:class:`~reviewboard.reviews.models.review_request.ReviewRequest`.
It's populated with default data that can be overridden by the caller.
Args:
review_request (reviewboard.reviews.models.review_request.
ReviewRequest):
The review request that ultimately owns the screenshot.
caption (unicode, optional):
The caption to use for the screenshot.
draft (bool or
reviewboard.reviews.models.review_request_draft.
ReviewRequestDraft):
A draft to associate the screenshot with. This can also be
a boolean, for legacy reasons, which will attempt to look up
or create a draft for the review request.
active (bool):
Whether this screenshot is considered active (not deleted).
**kwargs (dict):
Additional fields to set on the screenshot.
Returns:
reviewboard.reviews.models.screenshot.Screenshot:
The resulting screenshot.
"""
screenshot = Screenshot(caption=caption, **kwargs)
filename = os.path.join(settings.STATIC_ROOT, 'rb', 'images',
'logo.png')
with open(filename, 'r') as f:
screenshot.image.save(filename, File(f), save=True)
if draft:
if isinstance(draft, ReviewRequestDraft):
review_request_draft = draft
else:
review_request_draft = \
ReviewRequestDraft.create(review_request)
if active:
screenshots = review_request_draft.screenshots
else:
screenshots = review_request_draft.inactive_screenshots
else:
if active:
screenshots = review_request.screenshots
else:
screenshots = review_request.inactive_screenshots
screenshots.add(screenshot)
return screenshot
def test_recipients_with_muted_review_requests(self):
"""Testing e-mail recipients when users mute a review request"""
dopey = User.objects.get(username='******')
admin = User.objects.get(username='******')
group = Group.objects.create(name='group')
group.users.add(admin)
group.save()
review_request = self.create_review_request(
summary='My test review request',
public=True)
review_request.target_people.add(dopey)
review_request.target_people.add(User.objects.get(username='******'))
review_request.target_groups.add(group)
review_request.save()
visit = self.create_visit(review_request, ReviewRequestVisit.MUTED,
dopey)
visit.save()
visit = self.create_visit(review_request, ReviewRequestVisit.MUTED,
admin)
visit.save()
draft = ReviewRequestDraft.create(review_request)
draft.summary = 'Summary changed'
draft.publish(user=review_request.submitter)
self.assertEqual(len(mail.outbox), 1)
self.assertValidRecipients(['doc', 'grumpy'])
def test_update_from_committed_change_with_rich_text_reset(self):
"""Testing ReviewRequestDraft.update_from_commit_id resets rich text
fields
"""
def get_change(repository, commit_to_get):
commit = Commit(
message='* This is a summary\n\n* This is a description.')
diff_filename = os.path.join(self.testdata_dir, 'git_readme.diff')
with open(diff_filename, 'r') as f:
commit.diff = f.read()
return commit
def get_file_exists(repository, path, revision, base_commit_id=None,
request=None):
return (path, revision) in [('/readme', 'd6613f5')]
review_request = ReviewRequest.objects.create(self.user,
self.repository)
draft = ReviewRequestDraft.create(review_request)
self.spy_on(draft.repository.get_change, call_fake=get_change)
self.spy_on(draft.repository.get_file_exists,
call_fake=get_file_exists)
draft.description_rich_text = True
draft.update_from_commit_id('4')
self.assertEqual(draft.summary, '* This is a summary')
self.assertEqual(draft.description, '* This is a description.')
self.assertFalse(draft.description_rich_text)
self.assertFalse(review_request.description_rich_text)
def test_limited_recipients_other_fields(self):
"""Testing that recipient limiting only happens when adding reviewers
"""
review_request = self.create_review_request(
summary='My test review request',
public=True)
review_request.email_message_id = "junk"
review_request.target_people.add(User.objects.get(username='******'))
review_request.save()
draft = ReviewRequestDraft.create(review_request)
draft.summary = 'Changed summary'
draft.target_people.add(User.objects.get(username='******'))
draft.publish(user=review_request.submitter)
from_email = get_email_address_for_user(review_request.submitter)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].from_email, self.sender)
self.assertEqual(mail.outbox[0].extra_headers['From'], from_email)
self.assertEqual(mail.outbox[0].subject,
'Re: Review Request %s: Changed summary'
% review_request.pk)
self.assertValidRecipients([review_request.submitter.username,
'dopey', 'grumpy'])
message = mail.outbox[0].message()
self.assertEqual(message['Sender'],
self._get_sender(review_request.submitter))
def test_add_reviewer_review_request_email(self):
"""Testing limited e-mail recipients
when adding a reviewer to an existing review request
"""
review_request = self.create_review_request(
summary='My test review request',
public=True)
review_request.email_message_id = "junk"
review_request.target_people.add(User.objects.get(username='******'))
review_request.save()
draft = ReviewRequestDraft.create(review_request)
draft.target_people.add(User.objects.get(username='******'))
draft.publish(user=review_request.submitter)
from_email = get_email_address_for_user(review_request.submitter)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].from_email, self.sender)
self.assertEqual(mail.outbox[0].extra_headers['From'], from_email)
self.assertEqual(mail.outbox[0].subject,
'Re: Review Request %s: My test review request'
% review_request.pk)
# The only included users should be the submitter and 'grumpy' (not
# 'dopey', since he was already included on the review request earlier)
self.assertValidRecipients([review_request.submitter.username,
'grumpy'])
message = mail.outbox[0].message()
self.assertEqual(message['Sender'],
self._get_sender(review_request.submitter))
def test_create_with_new_draft_and_custom_changedesc(self):
"""Testing ReviewRequestDraft.create with new draft and custom
ChangeDescription
"""
review_request = self.create_review_request(
publish=True,
bugs_closed='1,20,300',
commit_id='abc123',
description_rich_text=True,
rich_text=True,
testing_done_rich_text=True,
extra_data={
'key': {
'values': [1, 2, 3],
},
'mybool': True,
})
# Create the draft.
changedesc = ChangeDescription.objects.create()
orig_draft = ReviewRequestDraft.create(review_request,
changedesc=changedesc)
self.assertEqual(orig_draft.changedesc_id, changedesc.pk)
self.assertEqual(ChangeDescription.objects.count(), 1)
# Reload to be sure.
draft = ReviewRequestDraft.objects.get(pk=orig_draft.pk)
self.assertEqual(orig_draft, draft)
self.assertEqual(draft.changedesc, changedesc)
def test_discard_unpublished_public(self):
"""Testing ReviewRequest.close with public requests on discard
to ensure changes from draft are not copied over
"""
review_request = self.create_review_request(
publish=False,
public=True)
self.assertTrue(review_request.public)
self.assertNotEqual(review_request.status, ReviewRequest.DISCARDED)
draft = ReviewRequestDraft.create(review_request)
summary = 'Test summary'
description = 'Test description'
testing_done = 'Test testing done'
draft.summary = summary
draft.description = description
draft.testing_done = testing_done
draft.save()
review_request.close(ReviewRequest.DISCARDED)
self.assertNotEqual(review_request.summary, summary)
self.assertNotEqual(review_request.description, description)
self.assertNotEqual(review_request.testing_done, testing_done)
def _test_put_with_text_type_escaping_all_fields(
self, text_type, text, expected_text):
self.assertIn(text_type, ('markdown', 'plain'))
rich_text = (text_type == 'markdown')
review_request = self.create_review_request(submitter=self.user,
publish=True)
review_request.rich_text = not rich_text
review_request.description = text
review_request.testing_done = text
review_request.save()
draft = ReviewRequestDraft.create(review_request)
draft.changedesc.text = text
draft.changedesc.save()
rsp = self.api_put(
get_review_request_draft_url(review_request),
{
'text_type': text_type,
},
expected_mimetype=review_request_draft_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
draft_rsp = rsp['draft']
self.assertEqual(draft_rsp['text_type'], text_type)
self.assertEqual(draft_rsp['changedescription'], expected_text)
self.assertEqual(draft_rsp['description'], expected_text)
self.assertEqual(draft_rsp['testing_done'], expected_text)
draft = ReviewRequestDraft.objects.get(pk=rsp['draft']['id'])
self.compare_item(draft_rsp, draft)
def create_file_attachment(self, review_request,
orig_filename='filename.png',
caption='My Caption',
draft=False,
active=True,
**kwargs):
"""Creates a FileAttachment for testing.
The FileAttachment is tied to the given ReviewRequest. It's populated
with default data that can be overridden by the caller.
"""
file_attachment = self._create_base_file_attachment(
caption=caption,
orig_filename=orig_filename,
**kwargs)
if draft:
review_request_draft = ReviewRequestDraft.create(review_request)
if active:
attachments = review_request_draft.file_attachments
else:
attachments = review_request_draft.inactive_file_attachments
else:
if active:
attachments = review_request.file_attachments
else:
attachments = review_request.inactive_file_attachments
attachments.add(file_attachment)
return file_attachment
def test_put_with_no_changes(self):
"""Testing the PUT review-requests/<id>/draft/ API
with no changes made to the fields
"""
review_request = self.create_review_request(submitter=self.user,
publish=True)
ReviewRequestDraft.create(review_request)
rsp = self.api_put(
get_review_request_draft_url(review_request),
{'public': True},
expected_status=NOTHING_TO_PUBLISH.http_status)
self.assertEqual(rsp['stat'], 'fail')
self.assertEqual(rsp['err']['code'], NOTHING_TO_PUBLISH.code)
def test_remove_person_and_fail_publish(self):
"""Testing counters when removing a person reviewer and then
failing to publish the draft
"""
self.test_add_person()
draft = ReviewRequestDraft.create(self.review_request)
draft.target_people.remove(self.user)
self._check_counters(total_outgoing=1,
pending_outgoing=1,
direct_incoming=1,
total_incoming=1,
starred_public=1)
self.spy_on(ReviewRequestDraft.publish,
call_fake=self._raise_publish_error)
with self.assertRaises(NotModifiedError):
self.review_request.publish(self.user)
self._check_counters(total_outgoing=1,
pending_outgoing=1,
direct_incoming=1,
total_incoming=1,
starred_public=1)
def test_put_with_commit_id_and_used_in_draft(self):
"""Testing the PUT review-requests/<id>/draft/ API with commit_id
used in another review request draft
"""
commit_id = 'abc123'
existing_review_request = self.create_review_request(
submitter=self.user,
publish=True)
existing_draft = ReviewRequestDraft.create(existing_review_request)
existing_draft.commit_id = commit_id
existing_draft.save()
review_request = self.create_review_request(submitter=self.user,
publish=True)
self.api_put(
get_review_request_draft_url(review_request),
{
'commit_id': commit_id,
},
expected_status=409)
review_request = ReviewRequest.objects.get(pk=review_request.pk)
self.assertIsNone(review_request.commit_id, None)
def test_populate_counters(self):
"""Testing counters when populated from a fresh upgrade or clear"""
# The review request was already created
draft = ReviewRequestDraft.create(self.review_request)
draft.target_groups.add(self.group)
draft.target_people.add(self.user)
self.review_request.publish(self.user)
self._check_counters(total_outgoing=1,
pending_outgoing=1,
total_incoming=1,
direct_incoming=1,
starred_public=1,
group_incoming=1)
LocalSiteProfile.objects.update(
direct_incoming_request_count=None,
total_incoming_request_count=None,
pending_outgoing_request_count=None,
total_outgoing_request_count=None,
starred_public_request_count=None)
Group.objects.update(incoming_request_count=None)
self._check_counters(total_outgoing=1,
pending_outgoing=1,
total_incoming=1,
direct_incoming=1,
starred_public=1,
group_incoming=1)
def create_diffset(self, review_request=None, revision=1, repository=None,
draft=False, name='diffset'):
"""Creates a DiffSet for testing.
The DiffSet defaults to revision 1. This can be overriden by the
caller.
DiffSets generally are tied to a ReviewRequest, but it's optional.
"""
if review_request:
repository = review_request.repository
diffset = DiffSet.objects.create(
name=name,
revision=revision,
repository=repository)
if review_request:
if draft:
review_request_draft = \
ReviewRequestDraft.create(review_request)
review_request_draft.diffset = diffset
review_request_draft.save()
else:
review_request.diffset_history.diffsets.add(diffset)
return diffset
def test_update_from_committed_change_with_rich_text_reset(self):
"""Testing ReviewRequestDraft.update_from_commit_id resets rich text
fields
"""
def get_change(repository, commit_to_get):
commit = Commit(
message='* This is a summary\n\n* This is a description.',
diff=self.DEFAULT_GIT_README_DIFF)
return commit
review_request = ReviewRequest.objects.create(self.user,
self.repository)
draft = ReviewRequestDraft.create(review_request)
self.spy_on(draft.repository.get_change, call_fake=get_change)
self.spy_on(draft.repository.get_file_exists)
draft.description_rich_text = True
draft.update_from_commit_id('4')
self.assertFalse(draft.repository.get_file_exists.called)
self.assertEqual(draft.summary, '* This is a summary')
self.assertEqual(draft.description, '* This is a description.')
self.assertFalse(draft.description_rich_text)
self.assertFalse(review_request.description_rich_text)
def create_screenshot(self, review_request, caption='My caption',
draft=False, active=True):
"""Creates a Screenshot for testing.
The Screenshot is tied to the given ReviewRequest. It's populated
with default data that can be overridden by the caller.
"""
screenshot = Screenshot(caption=caption)
filename = os.path.join(settings.STATIC_ROOT, 'rb', 'images',
'logo.png')
with open(filename, 'r') as f:
screenshot.image.save(filename, File(f), save=True)
if draft:
review_request_draft = ReviewRequestDraft.create(review_request)
if active:
screenshots = review_request_draft.screenshots
else:
screenshots = review_request_draft.inactive_screenshots
else:
if active:
screenshots = review_request.screenshots
else:
screenshots = review_request.inactive_screenshots
screenshots.add(screenshot)
return screenshot
def test_should_render_no_history_draft(self):
"""Testing CommitListField.should_render with a draft of a review
request created without history
"""
review_request = self.create_review_request()
draft = ReviewRequestDraft.create(review_request)
field = CommitListField(draft)
self.assertFalse(field.should_render)
def test_can_record_change_entry_no_history_draft(self):
"""Testing CommitListField.can_record_change_entry with a draft of a
review request created without history
"""
review_request = self.create_review_request()
draft = ReviewRequestDraft.create(review_request)
field = CommitListField(draft)
self.assertFalse(field.can_record_change_entry)
def create(self, file, review_request):
screenshot = Screenshot(caption=self.cleaned_data['caption'],
draft_caption=self.cleaned_data['caption'])
screenshot.image.save(file.name, file, save=True)
draft = ReviewRequestDraft.create(review_request)
draft.screenshots.add(screenshot)
draft.save()
return screenshot
def test_should_render_history_draft(self):
"""Testing CommitListField.should_render with a draft of a review
request created with history
"""
review_request = self.create_review_request(create_with_history=True)
draft = ReviewRequestDraft.create(review_request)
request = self._build_review_request_get(review_request)
field = CommitListField(draft, request=request)
self.assertTrue(field.should_render)
def setup_basic_put_test(self, user, with_local_site, local_site_name,
put_valid_data):
review_request = self.create_review_request(
with_local_site=with_local_site, submitter=user, publish=True)
draft = ReviewRequestDraft.create(review_request)
return (get_review_request_draft_url(review_request, local_site_name),
review_request_draft_item_mimetype, {
'description': 'New description',
}, draft, [review_request])
def setup_basic_get_test(self, user, with_local_site, local_site_name):
review_request = self.create_review_request(
with_local_site=with_local_site,
submitter=user,
publish=True)
draft = ReviewRequestDraft.create(review_request)
return (get_review_request_draft_url(review_request, local_site_name),
review_request_draft_item_mimetype,
draft)
def test_publish_with_add_another_file_attachment(self):
"""Testing ReviewRequestDraft.publish with adding another file
attachment
"""
user = User.objects.create_user(username='******')
review_request = self.create_review_request(target_people=[user])
attachment1 = self.create_file_attachment(review_request,
caption='File 1')
review_request.publish(review_request.submitter)
draft = ReviewRequestDraft.create(review_request)
self.assertEqual(draft.file_attachments_count, 1)
self.assertEqual(draft.inactive_file_attachments_count, 0)
self.assertEqual(review_request.file_attachments_count, 1)
self.assertEqual(review_request.inactive_file_attachments_count, 0)
attachment2 = self.create_file_attachment(review_request,
caption='File 2',
draft_caption='New File 2',
draft=draft)
self.assertEqual(draft.file_attachments_count, 2)
self.assertEqual(draft.inactive_file_attachments_count, 0)
self.assertEqual(review_request.file_attachments_count, 1)
self.assertEqual(review_request.inactive_file_attachments_count, 0)
changes = draft.publish()
attachment1 = FileAttachment.objects.get(pk=attachment1.pk)
self.assertEqual(attachment1.caption, 'File 1')
attachment2 = FileAttachment.objects.get(pk=attachment2.pk)
self.assertEqual(attachment2.caption, 'New File 2')
fields = changes.fields_changed
self.assertEqual(
fields['files'], {
'new': [
(attachment1.display_name, attachment1.get_absolute_url(),
attachment1.pk),
(attachment2.display_name, attachment2.get_absolute_url(),
attachment2.pk),
],
'added': [
(attachment2.display_name, attachment2.get_absolute_url(),
attachment2.pk),
],
'old': [
(attachment1.display_name, attachment1.get_absolute_url(),
attachment1.pk),
],
'removed': [],
})
self.assertEqual(review_request.file_attachments_count, 2)
self.assertEqual(review_request.inactive_file_attachments_count, 0)
def test_update_from_committed_change_without_repository_support(self):
"""Testing ReviewRequestDraft.update_from_commit_id without
supports_post_commmit for repository
"""
self.spy_on(self.repository.__class__.supports_post_commit.fget,
call_fake=lambda self: False)
review_request = ReviewRequest.objects.create(self.user,
self.repository)
draft = ReviewRequestDraft.create(review_request)
with self.assertRaises(NotImplementedError):
draft.update_from_commit_id('4')
def create(self, request, parent_request_id, *args, **kwargs):
try:
parent_rr = ReviewRequest.objects.get(pk=parent_request_id)
except ReviewRequest.DoesNotExist:
return DOES_NOT_EXIST
if not (parent_rr.is_accessible_by(request.user)
or parent_rr.is_mutable_by(request.user)):
return PERMISSION_DENIED
if not is_parent(parent_rr):
return NOT_PARENT
with transaction.atomic():
for child_rr in gen_child_rrs(parent_rr):
if child_rr.get_draft() is None:
ReviewRequestDraft.create(child_rr)
if parent_rr.get_draft() is None:
ReviewRequestDraft.create(parent_rr)
return 200, {}
def create(self, file_attachment, review_request):
comment = FileAttachmentComment(text=self.cleaned_data['review'],
file_attachment=file_attachment)
comment.timestamp = timezone.now()
comment.save(save=True)
draft = ReviewRequestDraft.create(review_request)
draft.file_attachment_comments.add(comment)
draft.save()
return comment
def test_publish_with_add_another_screenshot(self):
"""Testing ReviewRequestDraft.publish with adding another screenshot"""
user = User.objects.create_user(username='******')
review_request = self.create_review_request(target_people=[user])
screenshot1 = self.create_screenshot(review_request, caption='File 1')
review_request.publish(review_request.submitter)
draft = ReviewRequestDraft.create(review_request)
self.assertEqual(draft.screenshots_count, 1)
self.assertEqual(draft.inactive_screenshots_count, 0)
self.assertEqual(review_request.screenshots_count, 1)
self.assertEqual(review_request.inactive_screenshots_count, 0)
screenshot2 = self.create_screenshot(review_request,
caption='File 2',
draft_caption='New File 2',
draft=draft)
self.assertEqual(draft.screenshots_count, 2)
self.assertEqual(draft.inactive_screenshots_count, 0)
self.assertEqual(review_request.screenshots_count, 1)
self.assertEqual(review_request.inactive_screenshots_count, 0)
changes = draft.publish()
screenshot1 = Screenshot.objects.get(pk=screenshot1.pk)
self.assertEqual(screenshot1.caption, 'File 1')
screenshot2 = Screenshot.objects.get(pk=screenshot2.pk)
self.assertEqual(screenshot2.caption, 'New File 2')
fields = changes.fields_changed
self.assertEqual(
fields['screenshots'], {
'new': [
(screenshot1.caption, screenshot1.get_absolute_url(),
screenshot1.pk),
(screenshot2.caption, screenshot2.get_absolute_url(),
screenshot2.pk),
],
'added': [
(screenshot2.caption, screenshot2.get_absolute_url(),
screenshot2.pk),
],
'old': [
(screenshot1.caption, screenshot1.get_absolute_url(),
screenshot1.pk),
],
'removed': [],
})
self.assertEqual(review_request.screenshots_count, 2)
self.assertEqual(review_request.inactive_screenshots_count, 0)
def test_create_with_existing_new_draft_existing_custom_changedesc(self):
"""Testing ReviewRequestDraft.create with existing draft and existing
custom ChangeDescription
"""
review_request = self.create_review_request(
publish=True,
bugs_closed='1,20,300',
commit_id='abc123',
description_rich_text=True,
rich_text=True,
testing_done_rich_text=True,
extra_data={
'key': {
'values': [1, 2, 3],
},
'mybool': True,
})
# Create the first draft.
orig_draft = ReviewRequestDraft.create(review_request)
orig_changedesc = orig_draft.changedesc
self.assertIsNotNone(orig_changedesc)
# Try to create it again.
draft = ReviewRequestDraft.create(review_request,
changedesc=orig_changedesc)
self.assertEqual(orig_draft, draft)
self.assertEqual(draft.changedesc, orig_changedesc)
# Reload to be sure.
draft = ReviewRequestDraft.objects.get(pk=draft.pk)
self.assertEqual(orig_draft, draft)
self.assertEqual(draft.changedesc, orig_changedesc)
# Make sure we have not created any new ChangeDescription in the
# database.
self.assertEqual(list(ChangeDescription.objects.all()),
[orig_changedesc])
def create(self, file, review_request):
caption = self.cleaned_data['caption']
file_attachment = FileAttachment(caption='',
draft_caption=caption,
mimetype=file.content_type)
file_attachment.file.save(file.name, file, save=True)
draft = ReviewRequestDraft.create(review_request)
draft.file_attachments.add(file_attachment)
draft.save()
return file_attachment
def _test_put_as_other_user(self, local_site=None):
review_request = self.create_review_request(
with_local_site=(local_site is not None),
submitter='dopey',
publish=True)
self.assertNotEqual(review_request.submitter, self.user)
ReviewRequestDraft.create(review_request)
if local_site:
local_site_name = local_site.name
else:
local_site_name = None
rsp = self.api_put(
get_review_request_draft_url(review_request, local_site_name), {
'description': 'New description',
},
expected_mimetype=review_request_draft_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
self.assertTrue(rsp['draft']['description'], 'New description')
def test_populate_counters_after_change(self):
"""Testing counter inc/dec on uninitialized counter fields"""
# The review request was already created
draft = ReviewRequestDraft.create(self.review_request)
draft.target_groups.add(self.group)
draft.target_people.add(self.user)
self._check_counters(total_outgoing=1, pending_outgoing=1)
LocalSiteProfile.objects.update(direct_incoming_request_count=None,
total_incoming_request_count=None,
pending_outgoing_request_count=None,
total_outgoing_request_count=None,
starred_public_request_count=None)
Group.objects.update(incoming_request_count=None)
profile_fields = [
'direct_incoming_request_count',
'total_incoming_request_count',
'pending_outgoing_request_count',
'total_outgoing_request_count',
'starred_public_request_count',
]
# Lock the fields so we don't re-initialize them on publish.
locks = {
self.site_profile: 1,
self.site_profile2: 1,
}
for field in profile_fields:
getattr(LocalSiteProfile, field)._locks = locks
Group.incoming_request_count._locks = locks
# Publish the review request. This will normally try to
# increment/decrement the counts, which it should ignore now.
self.review_request.publish(self.user)
# Unlock the profiles so we can query/re-initialize them again.
for field in profile_fields:
getattr(LocalSiteProfile, field)._locks = {}
Group.incoming_request_count._locks = {}
self._check_counters(total_outgoing=1,
pending_outgoing=1,
direct_incoming=1,
total_incoming=1,
starred_public=1,
group_incoming=1)
def test_add_person(self):
"""Testing counters when adding a person reviewer"""
draft = ReviewRequestDraft.create(self.review_request)
draft.target_people.add(self.user)
self._check_counters(total_outgoing=1, pending_outgoing=1)
self.review_request.publish(self.user)
self._check_counters(total_outgoing=1,
pending_outgoing=1,
direct_incoming=1,
total_incoming=1,
starred_public=1)
def test_get_last_activity_info_draft(self):
"""Testing ReviewRequest.get_last_activity_info after updating the
draft
"""
draft = ReviewRequestDraft.create(self.review_request)
draft.summary = 'A new summary appears'
draft.save()
self.assertEqual(
self.review_request.get_last_activity_info(), {
'changedesc': None,
'timestamp': self.review_request.last_updated,
'updated_object': self.review_request,
})
def test_add_group(self):
"""Testing counters when adding a group reviewer"""
draft = ReviewRequestDraft.create(self.review_request)
draft.summary = 'Test Summary'
draft.target_groups.add(self.group)
self._check_counters(total_outgoing=1, pending_outgoing=1)
self.review_request.publish(self.user)
self._check_counters(total_outgoing=1,
pending_outgoing=1,
total_incoming=1,
group_incoming=1,
starred_public=1)
def test_publish_without_reviewer_or_group(self):
"""Testing ReviewRequestDraft.publish when there isn't a reviewer or
group name"""
review_request = self.create_review_request()
draft = ReviewRequestDraft.create(review_request)
draft.summary = 'New summary'
draft.description = 'New description'
draft.testing_done = 'New testing done'
draft.branch = 'New branch'
draft.bugs_closed = '12, 34, 56'
error_message = ('There must be at least one reviewer before this '
'review request can be published.')
with self.assertRaisesMessage(PublishError, error_message):
draft.publish()
def test_outgoing_requests(self):
"""Testing counters with creating outgoing review requests"""
# The review request was already created
self._check_counters(total_outgoing=1, pending_outgoing=1)
draft = ReviewRequestDraft.create(self.review_request)
draft.target_people = [self.user]
draft.save()
self.review_request.publish(self.user)
self._check_counters(direct_incoming=1,
total_incoming=1,
total_outgoing=1,
pending_outgoing=1,
starred_public=1)
def test_update_from_committed_change(self):
"""Testing ReviewRequestDraft.update_from_commit_id with committed
change
"""
commit_id = '4'
def get_change(repository, commit_to_get):
self.assertEqual(commit_id, commit_to_get)
commit = Commit(message='This is my commit message\n\n'
'With a summary line too.')
diff_filename = os.path.join(self.testdata_dir, 'git_readme.diff')
with open(diff_filename, 'r') as f:
commit.diff = f.read()
return commit
def get_file_exists(repository,
path,
revision,
base_commit_id=None,
request=None):
return (path, revision) in [('/readme', 'd6613f5')]
review_request = ReviewRequest.objects.create(self.user,
self.repository)
draft = ReviewRequestDraft.create(review_request)
self.spy_on(draft.repository.get_change, call_fake=get_change)
self.spy_on(draft.repository.get_file_exists,
call_fake=get_file_exists)
draft.update_from_commit_id(commit_id)
self.assertEqual(review_request.summary, '')
self.assertEqual(review_request.description, '')
self.assertEqual(draft.summary, 'This is my commit message')
self.assertEqual(draft.description, 'With a summary line too.')
self.assertEqual(review_request.diffset_history.diffsets.count(), 0)
self.assertIsNotNone(draft.diffset)
self.assertEqual(draft.diffset.files.count(), 1)
filediff = draft.diffset.files.get()
self.assertEqual(filediff.source_file, 'readme')
self.assertEqual(filediff.source_revision, 'd6613f5')
def test_publish_without_description(self):
"""Testing publish when there isn't a description"""
review_request = self.create_review_request()
draft = ReviewRequestDraft.create(review_request)
draft.testing_done = 'New testing done'
draft.branch = 'New branch'
draft.bugs_closed = '12, 34, 56'
draft.target_people = [self.user]
# Description is set by default in create_review_request
draft.description = ''
error_message = 'The draft must have a description.'
with self.assertRaisesMessage(PublishError, error_message):
draft.publish()
def create(self, file, review_request):
caption = self.cleaned_data['caption'] or file.name
mimetype = file.content_type or self._guess_mimetype(file)
filename = '%s__%s' % (uuid4(), file.name)
file_attachment = FileAttachment(
caption='',
draft_caption=caption,
orig_filename=os.path.basename(file.name),
mimetype=mimetype)
file_attachment.file.save(filename, file, save=True)
draft = ReviewRequestDraft.create(review_request)
draft.file_attachments.add(file_attachment)
draft.save()
return file_attachment
def test_get_last_activity_info_update(self):
"""Testing ReviewRequest.get_last_activity_info after an update"""
draft = ReviewRequestDraft.create(self.review_request)
draft.summary = 'A new summary appears'
draft.save()
self.review_request = ReviewRequest.objects.get(
pk=self.review_request.pk)
self.review_request.publish(user=self.review_request.submitter)
changedesc = self.review_request.changedescs.latest()
self.assertEqual(
self.review_request.get_last_activity_info(), {
'changedesc': changedesc,
'timestamp': changedesc.timestamp,
'updated_object': self.review_request,
})
def test_get_last_activity_for_updated_review_request(self):
"""Testing ReviewRequest.get_last_activity returns the review request
when it is updated
"""
user = User.objects.get(username='******')
review_request = self.create_review_request(publish=True,
create_repository=True,
target_people=[user])
draft = ReviewRequestDraft.create(review_request)
draft.summary = 'This is a new summary.'
draft.save()
review_request.publish(user=review_request.submitter)
timestamp, updated_object = review_request.get_last_activity()
changedesc = review_request.changedescs.latest()
self.assertEqual(updated_object, review_request)
self.assertEqual(timestamp, changedesc.timestamp)
def test_update_from_committed_change_without_repository_support(self):
"""Testing ReviewRequestDraft.update_from_commit_id without
supports_post_commmit for repository
"""
scmtool_cls = type(self.repository.get_scmtool())
old_supports_post_commit = scmtool_cls.supports_post_commit
scmtool_cls.supports_post_commit = False
try:
review_request = ReviewRequest.objects.create(
self.user, self.repository)
draft = ReviewRequestDraft.create(review_request)
with self.assertRaises(NotImplementedError):
draft.update_from_commit_id('4')
finally:
scmtool_cls.supports_post_commit = old_supports_post_commit
def test_put_publish_with_new_submitter(self):
"""Testing the PUT review-requests/<id>/draft/?public=1 API
with new submitter"""
review_request = self.create_review_request(submitter=self.user,
publish=True)
draft = ReviewRequestDraft.create(review_request)
draft.owner = User.objects.get(username='******')
draft.save()
rsp = self.api_put(
get_review_request_draft_url(review_request), {'public': True},
expected_mimetype=review_request_draft_item_mimetype)
self.assertEqual(rsp['stat'], 'ok')
review_request = ReviewRequest.objects.get(pk=review_request.id)
self.assertEqual(review_request.submitter.username, "doc")
self.assertTrue(review_request.public)
def test_on_the_fly_indexing_review_requests(self):
"""Testing on-the-fly indexing for review requests"""
reindex_search()
siteconfig = SiteConfiguration.objects.get_current()
siteconfig.set('search_on_the_fly_indexing', True)
siteconfig.save()
group = self.create_review_group()
invite_only_group = self.create_review_group(name='invite-only-group',
invite_only=True)
grumpy = User.objects.get(username='******')
try:
self.spy_on(signal_processor.handle_save)
review_request = self.create_review_request(summary='foo',
publish=True)
self.assertTrue(signal_processor.handle_save.spy.called)
draft = ReviewRequestDraft.create(review_request)
draft.summary = 'Not foo whatsoever'
draft.save()
draft.target_people = [grumpy]
draft.target_groups = [group, invite_only_group]
review_request.publish(review_request.submitter)
rsp = self.search('Not foo')
finally:
siteconfig = SiteConfiguration.objects.get_current()
siteconfig.set('search_on_the_fly_indexing', False)
siteconfig.save()
# There will be one call from each publish.
self.assertEqual(len(signal_processor.handle_save.spy.calls), 2)
self.assertEqual(rsp.context['hits_returned'], 1)
result = rsp.context['result']
self.assertEqual(result.summary, 'Not foo whatsoever')
self.assertEqual(result.target_users, [six.text_type(grumpy.pk)])
self.assertEqual(result.private_target_groups,
[six.text_type(invite_only_group.pk)])
def test_publish_without_summary(self):
"""Testing publish when there isn't a summary"""
review_request = self.create_review_request()
draft = ReviewRequestDraft.create(review_request)
target_person = User.objects.get(username='******')
draft.description = 'New description'
draft.testing_done = 'New testing done'
draft.branch = 'New branch'
draft.bugs_closed = '12, 34, 56'
draft.target_people = [target_person]
# Summary is set by default in create_review_request
draft.summary = ''
error_message = 'The draft must have a summary.'
with self.assertRaisesMessage(PublishError, error_message):
draft.publish()
def test_deleting_requests(self):
"""Testing counters with deleting outgoing review requests"""
# The review request was already created
self._check_counters(total_outgoing=1, pending_outgoing=1)
draft = ReviewRequestDraft.create(self.review_request)
draft.target_groups.add(self.group)
draft.target_people.add(self.user)
self.review_request.publish(self.user)
self._check_counters(total_outgoing=1,
pending_outgoing=1,
direct_incoming=1,
total_incoming=1,
starred_public=1,
group_incoming=1)
self.review_request.delete()
self._check_counters()
