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()